@rigstate/cli 0.6.0

package/src/index.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { createLoginCommand } from './commands/login.js';
+import { createLinkCommand } from './commands/link.js';
+import { createScanCommand } from './commands/scan.js';
+import { createFixCommand } from './commands/fix.js';
+import { createSyncCommand } from './commands/sync.js';
+import { createInitCommand } from './commands/init.js';
+import { createCheckCommand } from './commands/check.js';
+import { createHooksCommand } from './commands/hooks.js';
+import { createDaemonCommand } from './commands/daemon.js';
+import { createWorkCommand } from './commands/work.js';
+import { createWatchCommand } from './commands/watch.js';
+import { createFocusCommand } from './commands/focus.js';
+import { createEnvPullCommand } from './commands/env.js';
+import { createConfigCommand } from './commands/config.js';
+import { createMcpCommand } from './commands/mcp.js';
+import { createNexusCommand } from './commands/nexus.js';
+import { createSyncRulesCommand } from './commands/sync-rules.js';
+import { createOverrideCommand } from './commands/override.js';
+import { checkVersion } from './utils/version.js';
+import dotenv from 'dotenv';
+
+// Load environment variables
+dotenv.config();
+
+const program = new Command();
+
+program
+    .name('rigstate')
+    .description('CLI for Rigstate - The AI-Native Dev Studio')
+    .version('0.2.0');
+
+// Register commands
+program.addCommand(createLoginCommand());
+program.addCommand(createLinkCommand());
+program.addCommand(createScanCommand());
+program.addCommand(createFixCommand());
+program.addCommand(createSyncCommand());
+program.addCommand(createInitCommand());
+program.addCommand(createCheckCommand());
+program.addCommand(createHooksCommand());
+program.addCommand(createDaemonCommand());
+program.addCommand(createWorkCommand());
+program.addCommand(createWatchCommand());
+program.addCommand(createFocusCommand());
+program.addCommand(createEnvPullCommand());
+program.addCommand(createConfigCommand());
+program.addCommand(createMcpCommand());
+program.addCommand(createNexusCommand());
+program.addCommand(createSyncRulesCommand());
+program.addCommand(createOverrideCommand());
+
+program.hook('preAction', async () => {
+    await checkVersion();
+});
+
+// Add helpful examples
+program.on('--help', () => {
+    console.log('');
+    console.log(chalk.bold('Examples:'));
+    console.log('');
+    console.log(chalk.cyan('  $ rigstate login sk_rigstate_your_api_key'));
+    console.log(chalk.dim('    Authenticate with your Rigstate API key'));
+    console.log('');
+    console.log(chalk.cyan('  $ rigstate scan'));
+    console.log(chalk.dim('    Scan the current directory'));
+    console.log('');
+    console.log(chalk.cyan('  $ rigstate scan ./src --project abc123'));
+    console.log(chalk.dim('    Scan a specific directory with project ID'));
+    console.log('');
+    console.log(chalk.cyan('  $ rigstate scan --json'));
+    console.log(chalk.dim('    Output results in JSON format (useful for IDE extensions)'));
+    console.log('');
+});
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/src/nexus/council.ts

@@ -0,0 +1,103 @@
+
+import { SwarmAgent, ServiceOrder } from '@rigstate/shared';
+
+export type AgentWeight = number;
+
+/**
+ * THE HIERARCHY OF RIGSTATE
+ * Defines the decision power of each agent in The Council.
+ */
+export const AGENT_WEIGHTS: Record<SwarmAgent, AgentWeight> = {
+    'FRANK': 100,  // SUPREME COURT (Security/Architecture) - Veto Power
+    'SVEN': 95,    // SENTINEL (Compliance/Audit) - Highly Authoritative
+    'SINDRE': 80,  // VAULT KEEPER (Data Integrity) - High Authority on Data
+    'MAJA': 70,    // SCRIBE (Documentation) - Advisory
+    'EITRI': 60    // BUILDER (Implementation) - Mutable, subservient to Architects
+};
+
+export interface Conflict {
+    id: string;
+    proposal: ServiceOrder;
+    objector: SwarmAgent;
+    reason: string;
+    severity: 'CRITICAL' | 'WARNING' | 'SUGGESTION';
+    alternativeProposal?: any;
+}
+
+export interface CouncilResolution {
+    outcome: 'UPHELD' | 'OVERRULED' | 'COMPROMISE';
+    winner: SwarmAgent;
+    action: 'BLOCK' | 'PROCEED' | 'MODIFY';
+    rationale: string;
+}
+
+/**
+ * THE COUNCIL v2
+ * Resolves disputes between agents using Weighted Democracy.
+ */
+export class Council {
+
+    /**
+     * Judges a conflict based on Agent weights and Hierarchy.
+     */
+    public resolve(conflict: Conflict): CouncilResolution {
+        const proposer = conflict.proposal.targetAgent; // The agent doing the work (e.g. Eitri)
+        const objector = conflict.objector;           // The agent complaining (e.g. Sven)
+
+        const proposerWeight = AGENT_WEIGHTS[proposer] || 50;
+        const objectorWeight = AGENT_WEIGHTS[objector] || 50;
+
+        console.log(`⚖️ COUNCIL IN SESSION: ${objector} (${objectorWeight}) objects to ${proposer} (${proposerWeight})`);
+
+        // 1. ABSOLUTE VETO (Frank/Sven on Critical Issues)
+        if ((objector === 'FRANK' || objector === 'SVEN') && conflict.severity === 'CRITICAL') {
+            return {
+                outcome: 'UPHELD',
+                winner: objector,
+                action: 'BLOCK',
+                rationale: `Absolute Veto by ${objector} on CRITICAL violation: ${conflict.reason}`
+            };
+        }
+
+        // 2. SUGGESTION OVERRIDE (Pragmatism)
+        // If it's just a suggestion, the Builder (Proposer) usually proceeds unless it's the Supreme Court (Frank).
+        if (conflict.severity === 'SUGGESTION' && objector !== 'FRANK') {
+            return {
+                outcome: 'OVERRULED',
+                winner: proposer,
+                action: 'PROCEED',
+                rationale: `Minor suggestion by ${objector} noted but overruled for velocity.`
+            };
+        }
+
+        // 3. WEIGHT COMPARISON
+        if (objectorWeight > proposerWeight) {
+            return {
+                outcome: 'UPHELD',
+                winner: objector,
+                action: 'BLOCK',
+                rationale: `${objector} outranks ${proposer}. Objection validated.`
+            };
+        }
+
+        // 4. TIE-BREAKER / LOWER AUTHORITY
+        // If weights are equal or objector is lower, we generally favor the builder (Proposer) 
+        // unless it's a security suggestion.
+        if (conflict.severity === 'SUGGESTION' && proposer === 'EITRI') {
+            return {
+                outcome: 'OVERRULED',
+                winner: proposer,
+                action: 'PROCEED',
+                rationale: `${proposer} has implementation authority on non-critical suggestions.`
+            };
+        }
+
+        // Default: Proposer wins if they outrank objector
+        return {
+            outcome: 'OVERRULED',
+            winner: proposer,
+            action: 'PROCEED',
+            rationale: `Objection overruled. ${proposer} retains authority.`
+        };
+    }
+}

package/src/nexus/dispatcher.ts

@@ -0,0 +1,133 @@
+
+import EventEmitter from 'events';
+import { ServiceOrder, SwarmAgent, NexusContext } from '@rigstate/shared';
+import { v4 as uuidv4 } from 'uuid';
+
+import { HiveGateway } from '../hive/gateway';
+import { Logger } from '../utils/logger';
+
+/**
+ * THE NEXUS DISPATCHER
+ * "The Brain Stem" of Rigstate.
+ * Routes ServiceOrders between agents and enforces the Human Kill-Switch.
+ */
+export class NexusDispatcher extends EventEmitter {
+    private context: NexusContext;
+    private orderQueue: ServiceOrder[] = [];
+    private orderHistory: ServiceOrder[] = [];
+    private gateway: HiveGateway;
+
+    constructor(context: NexusContext) {
+        super();
+        this.context = context;
+        this.gateway = new HiveGateway(
+            process.env.RIGSTATE_HIVE_URL || 'https://rigstate.com/api/hive',
+            process.env.RIGSTATE_HIVE_TOKEN
+        );
+        Logger.info(`🧠 NEXUS DISPATCHER ONLINE. Context: ${context.projectId} (DryRun: ${context.dryRun})`);
+    }
+
+    /**
+     * Creates a new Service Order and routes it.
+     */
+    public async dispatch(
+        source: SwarmAgent,
+        target: SwarmAgent,
+        intent: string,
+        action: string,
+        params: Record<string, any>,
+        constraints: string[] = []
+    ): Promise<ServiceOrder> {
+
+        const order: ServiceOrder = {
+            id: uuidv4(),
+            traceId: uuidv4(), // TODO: Inherit traceId if chained
+            sourceAgent: source,
+            targetAgent: target,
+            priority: 'NORMAL',
+            intent,
+            action,
+            parameters: params,
+            constraints,
+            status: 'PENDING',
+            createdAt: new Date().toISOString()
+        };
+
+        this.orderQueue.push(order);
+        this.emit('order:created', order);
+
+        // Security / Kill-Switch Check
+        // EITRI (The Smith) is the only one who can hammer the metal (write files)
+        if (target === 'EITRI' && order.action.startsWith('fs.write')) {
+            if (this.context.dryRun) {
+                Logger.info(`🛑 NEXUS KILL-SWITCH: Order ${order.id} blocked by Dry-Run protocol.`);
+                order.status = 'PENDING'; // Kept as PENDING but blocked
+                // Ideally status should represent AWAITING_APPROVAL explicitly
+                // But for now strict dry-run just prevents execution
+                this.emit('order:blocked', order);
+                return order;
+            }
+        }
+
+        // If automatic or dry-run disabled
+        return this.executeOrder(order);
+    }
+
+    /**
+     * Executes the order (simulated for now, essentially "Sending" it)
+     */
+    private async executeOrder(order: ServiceOrder): Promise<ServiceOrder> {
+        order.status = 'EXECUTING';
+        order.startedAt = new Date().toISOString();
+        this.emit('order:started', order);
+
+        try {
+            Logger.info(`🚀 NEXUS: Routing Order ${order.id} [${order.sourceAgent} -> ${order.targetAgent}]: ${order.intent}`);
+
+            // SPECIAL ROUTING: HIVE UPLINK
+            if (order.targetAgent === 'MAJA' && order.action === 'HIVE_TRANSMIT') {
+                const signal = order.parameters.signal;
+                if (signal) {
+                    await this.gateway.transmit(signal);
+                    order.status = 'COMPLETED';
+                    return order;
+                }
+            }
+
+            // Here we would actually call the Agent's handler function
+            // For now, we just emit the specific event for listeners
+            this.emit(`agent:${order.targetAgent}`, order);
+
+            // Simulation of async completion would happen via callback/promise resolution elsewhere
+            return order;
+
+        } catch (error: unknown) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            Logger.error(`Dispatch failed for order ${order.id}`, error);
+
+            order.status = 'FAILED';
+            order.error = {
+                code: 'DISPATCH_ERROR',
+                message: errorMessage
+            };
+            this.emit('order:failed', order);
+            return order;
+        }
+    }
+
+    /**
+     * Human Approval (The "Red Button")
+     */
+    public async approveOrder(orderId: string): Promise<void> {
+        const order = this.orderQueue.find(o => o.id === orderId);
+        if (!order) throw new Error(`Order ${orderId} not found`);
+
+        if (order.status !== 'AWAITING_APPROVAL') {
+            Logger.warn(`Order ${orderId} is not awaiting approval (Status: ${order.status})`);
+            return;
+        }
+
+        Logger.info(`✅ HUMAN APPROVED Order ${orderId}`);
+        await this.executeOrder(order);
+    }
+}

package/src/utils/config.ts

@@ -0,0 +1,83 @@
+import Conf from 'conf';
+
+interface RigstateConfig {
+    apiKey?: string;
+    projectId?: string;
+    apiUrl?: string;
+}
+
+const config = new Conf<RigstateConfig>({
+    projectName: 'rigstate-cli',
+    defaults: {
+        apiUrl: 'http://localhost:3000',
+    },
+});
+
+/**
+ * Get the stored API key
+ * @throws {Error} If no API key is found (user not logged in)
+ */
+export function getApiKey(): string {
+    const apiKey = config.get('apiKey');
+    if (!apiKey) {
+        throw new Error(
+            '❌ Not logged in. Please run "rigstate login <your-api-key>" first.'
+        );
+    }
+    return apiKey;
+}
+
+/**
+ * Set the API key
+ */
+export function setApiKey(key: string): void {
+    config.set('apiKey', key);
+}
+
+/**
+ * Get the default project ID (if set)
+ */
+export function getProjectId(): string | undefined {
+    return config.get('projectId');
+}
+
+/**
+ * Set the default project ID
+ */
+export function setProjectId(projectId: string): void {
+    config.set('projectId', projectId);
+}
+
+/**
+ * Get the API URL
+ * Priority: Environment variable > Stored config > Production default
+ */
+export function getApiUrl(): string {
+    // 1. Check environment variable first
+    if (process.env.RIGSTATE_API_URL) {
+        return process.env.RIGSTATE_API_URL;
+    }
+    // 2. Check stored config
+    const storedUrl = config.get('apiUrl');
+    if (storedUrl) {
+        return storedUrl;
+    }
+    // 3. Default to production
+    return 'https://app.rigstate.com';
+}
+
+/**
+ * Set the API URL
+ */
+export function setApiUrl(url: string): void {
+    config.set('apiUrl', url);
+}
+
+/**
+ * Clear all config
+ */
+export function clearConfig(): void {
+    config.clear();
+}
+
+export { config };

package/src/utils/files.ts

@@ -0,0 +1,95 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * Read and parse .gitignore file
+ */
+export async function readGitignore(dir: string): Promise<string[]> {
+    const gitignorePath = path.join(dir, '.gitignore');
+    try {
+        const content = await fs.readFile(gitignorePath, 'utf-8');
+        return content
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line && !line.startsWith('#'));
+    } catch (error) {
+        // No .gitignore file found, return empty array
+        return [];
+    }
+}
+
+/**
+ * Check if a path should be ignored based on .gitignore patterns
+ */
+export function shouldIgnore(filePath: string, patterns: string[]): boolean {
+    const relativePath = filePath.replace(/^\.\//, '');
+
+    // Default ignore patterns
+    const defaultIgnores = [
+        'node_modules',
+        '.git',
+        'dist',
+        'build',
+        '.next',
+        '.turbo',
+        'coverage',
+        '.env',
+        '.env.local',
+    ];
+
+    const allPatterns = [...defaultIgnores, ...patterns];
+
+    for (const pattern of allPatterns) {
+        if (pattern.endsWith('/')) {
+            // Directory pattern
+            const dir = pattern.slice(0, -1);
+            if (relativePath.includes(`${dir}/`) || relativePath === dir) {
+                return true;
+            }
+        } else if (pattern.includes('*')) {
+            // Glob pattern - simple implementation
+            const regex = new RegExp(
+                '^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$'
+            );
+            if (regex.test(relativePath)) {
+                return true;
+            }
+        } else {
+            // Exact match or contains
+            if (relativePath.includes(pattern)) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Check if file is a code file based on extension
+ */
+export function isCodeFile(filePath: string): boolean {
+    const codeExtensions = [
+        '.js',
+        '.jsx',
+        '.ts',
+        '.tsx',
+        '.py',
+        '.java',
+        '.go',
+        '.rb',
+        '.php',
+        '.c',
+        '.cpp',
+        '.h',
+        '.cs',
+        '.swift',
+        '.kt',
+        '.rs',
+        '.vue',
+        '.svelte',
+    ];
+
+    const ext = path.extname(filePath).toLowerCase();
+    return codeExtensions.includes(ext);
+}

package/src/utils/governance.ts

@@ -0,0 +1,128 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+
+// --- Types ---
+
+export enum InterventionLevel {
+    GHOST = 0,    // Log only, silent
+    NUDGE = 1,    // Warn on commit/complete
+    SENTINEL = 2  // Immediate SOFT_LOCK
+}
+
+export type LockStatus = 'OPEN' | 'SOFT_LOCK';
+
+export interface GovernanceConfig {
+    governance: {
+        intervention_level: InterventionLevel;
+        allow_overrides: boolean;
+    };
+}
+
+export interface SessionState {
+    status: LockStatus;
+    active_violation?: string | null;
+    lock_reason?: string | null;
+    last_updated: string;
+}
+
+const DEFAULT_CONFIG: GovernanceConfig = {
+    governance: {
+        intervention_level: InterventionLevel.GHOST,
+        allow_overrides: true
+    }
+};
+
+const DEFAULT_SESSION: SessionState = {
+    status: 'OPEN',
+    active_violation: null,
+    lock_reason: null,
+    last_updated: new Date().toISOString()
+};
+
+// --- Config Management ---
+
+export async function getGovernanceConfig(rootDir: string = process.cwd()): Promise<GovernanceConfig> {
+    try {
+        const configPath = path.join(rootDir, 'rigstate.config.json');
+        const content = await fs.readFile(configPath, 'utf-8');
+        const userConfig = JSON.parse(content);
+        return {
+            governance: {
+                ...DEFAULT_CONFIG.governance,
+                ...userConfig.governance
+            }
+        };
+    } catch (e) {
+        return DEFAULT_CONFIG;
+    }
+}
+
+// --- Session State Management ---
+
+export async function getSessionState(rootDir: string = process.cwd()): Promise<SessionState> {
+    try {
+        const sessionPath = path.join(rootDir, '.rigstate', 'session.json');
+        const content = await fs.readFile(sessionPath, 'utf-8');
+        return JSON.parse(content);
+    } catch (e) {
+        return DEFAULT_SESSION;
+    }
+}
+
+export async function setSoftLock(
+    reason: string,
+    violationId: string,
+    rootDir: string = process.cwd()
+): Promise<void> {
+    const sessionPath = path.join(rootDir, '.rigstate', 'session.json');
+    const state: SessionState = {
+        status: 'SOFT_LOCK',
+        active_violation: violationId,
+        lock_reason: reason,
+        last_updated: new Date().toISOString()
+    };
+
+    await fs.mkdir(path.dirname(sessionPath), { recursive: true });
+    await fs.writeFile(sessionPath, JSON.stringify(state, null, 2), 'utf-8');
+}
+
+export async function clearSoftLock(
+    rootDir: string = process.cwd()
+): Promise<void> {
+    const sessionPath = path.join(rootDir, '.rigstate', 'session.json');
+    const state: SessionState = {
+        ...DEFAULT_SESSION,
+        last_updated: new Date().toISOString()
+    };
+
+    await fs.mkdir(path.dirname(sessionPath), { recursive: true });
+    await fs.writeFile(sessionPath, JSON.stringify(state, null, 2), 'utf-8');
+}
+
+/**
+ * Checks if the user is authorized to perform an override
+ * (For now, assumes CLI user is authorized, but logs it)
+ */
+export async function performOverride(
+    violationId: string,
+    reason: string,
+    rootDir: string = process.cwd()
+): Promise<boolean> {
+    const config = await getGovernanceConfig(rootDir);
+
+    if (!config.governance.allow_overrides) {
+        console.log(chalk.red('❌ Overrides are disabled for this project.'));
+        return false;
+    }
+
+    // Security violations (SEC-*) cannot be overridden via CLI usually, 
+    // but the implementation here depends on how we define "Security".
+    // For now, we allow overriding via this function, but the *Caller* should check violation type.
+
+    await clearSoftLock(rootDir);
+    // TODO: Add to Mission Report (Audit Log)
+    // We will handle logging in the command handler itself
+
+    return true;
+}

package/src/utils/logger.ts

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+
+export enum LogLevel {
+    INFO = 'INFO',
+    WARN = 'WARN',
+    ERROR = 'ERROR',
+    DEBUG = 'DEBUG'
+}
+
+export class Logger {
+    private static formatMessage(level: LogLevel, message: string, context?: unknown): string {
+        const timestamp = new Date().toISOString();
+        let prefix = '';
+
+        switch (level) {
+            case LogLevel.INFO:
+                prefix = chalk.blue(`[${LogLevel.INFO}]`);
+                break;
+            case LogLevel.WARN:
+                prefix = chalk.yellow(`[${LogLevel.WARN}]`);
+                break;
+            case LogLevel.ERROR:
+                prefix = chalk.red(`[${LogLevel.ERROR}]`);
+                break;
+            case LogLevel.DEBUG:
+                prefix = chalk.gray(`[${LogLevel.DEBUG}]`);
+                break;
+        }
+
+        let output = `${chalk.gray(timestamp)} ${prefix} ${message}`;
+
+        if (context) {
+            if (context instanceof Error) {
+                output += `\n${chalk.red(context.stack || context.message)}`;
+            } else if (typeof context === 'object') {
+                try {
+                    output += `\n${chalk.gray(JSON.stringify(context, null, 2))}`;
+                } catch (e) {
+                    output += `\n${chalk.gray('[Circular or invalid object]')}`;
+                }
+            } else {
+                output += ` ${String(context)}`;
+            }
+        }
+
+        return output;
+    }
+
+    static info(message: string, context?: unknown) {
+        console.log(this.formatMessage(LogLevel.INFO, message, context));
+    }
+
+    static warn(message: string, context?: unknown) {
+        console.warn(this.formatMessage(LogLevel.WARN, message, context));
+    }
+
+    static error(message: string, error?: unknown) {
+        console.error(this.formatMessage(LogLevel.ERROR, message, error));
+    }
+
+    static debug(message: string, context?: unknown) {
+        if (process.env.DEBUG || process.env.RIGSTATE_DEBUG) {
+            console.debug(this.formatMessage(LogLevel.DEBUG, message, context));
+        }
+    }
+}