@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/bin/commands/mode.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+
+/**
+ * BOSS CLAUDE MODE COMMAND
+ *
+ * Usage:
+ *   boss-claude mode                    # Show current mode
+ *   boss-claude mode orchestrator       # Switch to orchestrator mode
+ *   boss-claude mode specialist         # Switch to specialist mode
+ *   boss-claude mode worker             # Switch to worker mode
+ *   boss-claude mode review             # Switch to review mode
+ *   boss-claude mode learning           # Switch to learning mode
+ *   boss-claude mode history            # Show mode change history
+ *   boss-claude mode stats              # Show mode statistics
+ *   boss-claude mode blocked            # Show blocked actions
+ *   boss-claude mode reset              # Emergency reset to safe default
+ */
+
+import { getEnforcer, MODES } from '../../lib/mode-enforcer.js';
+import { getGate } from '../../lib/orchestrator-gate.js';
+import chalk from 'chalk';
+
+export async function modeCommand(args) {
+  const enforcer = getEnforcer();
+  const gate = getGate();
+
+  // No args - show current mode
+  if (!args || args.length === 0) {
+    await showCurrentMode(enforcer, gate);
+    return;
+  }
+
+  const subcommand = args[0].toLowerCase();
+
+  switch (subcommand) {
+    case 'orchestrator':
+    case 'specialist':
+    case 'worker':
+    case 'review':
+    case 'learning':
+      await switchMode(enforcer, subcommand, args);
+      break;
+
+    case 'history':
+      await showHistory(enforcer);
+      break;
+
+    case 'stats':
+      await showStats(enforcer);
+      break;
+
+    case 'blocked':
+      await showBlockedActions(enforcer);
+      break;
+
+    case 'reset':
+      await resetMode(enforcer);
+      break;
+
+    case 'status':
+      await gate.printStatus();
+      break;
+
+    default:
+      console.error(chalk.red(`Unknown mode command: ${subcommand}`));
+      console.log(chalk.yellow(`\nValid modes: orchestrator, specialist, worker, review, learning`));
+      console.log(chalk.yellow(`Valid commands: history, stats, blocked, reset, status`));
+      process.exit(1);
+  }
+}
+
+// ==========================================
+// SHOW CURRENT MODE
+// ==========================================
+async function showCurrentMode(enforcer, gate) {
+  const currentMode = await enforcer.getCurrentMode();
+  const metadata = await enforcer.getModeMetadata();
+  const agentIdentity = await enforcer.getAgentIdentity();
+
+  console.log(chalk.bold.cyan(`\n╔══════════════════════════════════════════════════════════╗`));
+  console.log(chalk.bold.cyan(`║          BOSS CLAUDE - CURRENT MODE                     ║`));
+  console.log(chalk.bold.cyan(`╚══════════════════════════════════════════════════════════╝\n`));
+
+  console.log(chalk.bold(`Mode: ${chalk.green(currentMode.toUpperCase())}`));
+
+  if (metadata) {
+    console.log(chalk.gray(`Set by: ${metadata.setBy}`));
+    console.log(chalk.gray(`Set at: ${metadata.setAt}`));
+    console.log(chalk.gray(`Reason: ${metadata.reason}`));
+    if (metadata.sessionId) {
+      console.log(chalk.gray(`Session: ${metadata.sessionId}`));
+    }
+    console.log(chalk.gray(`TTL: ${metadata.ttl} seconds`));
+  }
+
+  if (agentIdentity) {
+    console.log(chalk.bold(`\nAgent: ${chalk.yellow(agentIdentity.agent)}`));
+    if (agentIdentity.domain) {
+      console.log(chalk.gray(`Domain: ${agentIdentity.domain}`));
+    }
+    console.log(chalk.gray(`Since: ${agentIdentity.setAt}`));
+  }
+
+  console.log(chalk.dim(`\nSwitch modes with: boss-claude mode [orchestrator|specialist|worker|review|learning]`));
+  console.log(chalk.dim(`View capabilities: boss-claude mode status\n`));
+}
+
+// ==========================================
+// SWITCH MODE
+// ==========================================
+async function switchMode(enforcer, mode, args) {
+  const validModes = Object.values(MODES);
+
+  if (!validModes.includes(mode)) {
+    console.error(chalk.red(`Invalid mode: ${mode}`));
+    console.log(chalk.yellow(`Valid modes: ${validModes.join(', ')}`));
+    process.exit(1);
+  }
+
+  // Parse additional args
+  const reason = args[1] || 'manual-switch';
+  const agent = args[2] || 'boss-claude';
+
+  console.log(chalk.bold.cyan(`\n[MODE SWITCH] Switching to ${mode.toUpperCase()} mode...`));
+
+  try {
+    await enforcer.setMode(mode, {
+      agent,
+      reason,
+      sessionId: null
+    });
+
+    // Update agent identity if switching to specialist
+    if (mode === MODES.SPECIALIST && args[2]) {
+      const domain = args[3] || null;
+      await enforcer.setAgentIdentity(args[2], domain);
+      console.log(chalk.green(`✅ Agent identity set: ${args[2]} (${domain || 'no domain'})`));
+    }
+
+    console.log(chalk.bold.green(`✅ Mode switched to: ${mode.toUpperCase()}`));
+    console.log(chalk.gray(`Reason: ${reason}`));
+
+    // Show new status
+    const gate = getGate();
+    await gate.printStatus();
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Failed to switch mode: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// ==========================================
+// SHOW HISTORY
+// ==========================================
+async function showHistory(enforcer) {
+  console.log(chalk.bold.cyan(`\n╔══════════════════════════════════════════════════════════╗`));
+  console.log(chalk.bold.cyan(`║          MODE CHANGE HISTORY                            ║`));
+  console.log(chalk.bold.cyan(`╚══════════════════════════════════════════════════════════╝\n`));
+
+  const history = await enforcer.getModeHistory(20);
+
+  if (history.length === 0) {
+    console.log(chalk.yellow(`No mode changes recorded yet.`));
+    return;
+  }
+
+  history.forEach((entry, index) => {
+    const timestamp = new Date(entry.setAt).toLocaleString();
+    console.log(chalk.bold(`${index + 1}. ${chalk.green(entry.mode.toUpperCase())}`));
+    console.log(chalk.gray(`   Time: ${timestamp}`));
+    console.log(chalk.gray(`   By: ${entry.setBy}`));
+    console.log(chalk.gray(`   Reason: ${entry.reason}`));
+    if (entry.sessionId) {
+      console.log(chalk.gray(`   Session: ${entry.sessionId}`));
+    }
+    console.log('');
+  });
+
+  console.log(chalk.dim(`Showing last ${history.length} mode changes\n`));
+}
+
+// ==========================================
+// SHOW STATS
+// ==========================================
+async function showStats(enforcer) {
+  console.log(chalk.bold.cyan(`\n╔══════════════════════════════════════════════════════════╗`));
+  console.log(chalk.bold.cyan(`║          MODE STATISTICS                                 ║`));
+  console.log(chalk.bold.cyan(`╚══════════════════════════════════════════════════════════╝\n`));
+
+  const stats = await enforcer.getModeStats();
+
+  console.log(chalk.bold(`Actions per mode:\n`));
+
+  for (const [mode, count] of Object.entries(stats)) {
+    const bar = '█'.repeat(Math.min(count, 50));
+    console.log(chalk.bold(`${mode.padEnd(15)}: ${chalk.green(count.toString().padStart(6))} ${chalk.gray(bar)}`));
+  }
+
+  const total = Object.values(stats).reduce((sum, count) => sum + count, 0);
+  console.log(chalk.bold(`\nTotal actions: ${chalk.cyan(total)}\n`));
+}
+
+// ==========================================
+// SHOW BLOCKED ACTIONS
+// ==========================================
+async function showBlockedActions(enforcer) {
+  console.log(chalk.bold.cyan(`\n╔══════════════════════════════════════════════════════════╗`));
+  console.log(chalk.bold.cyan(`║          BLOCKED ACTIONS (Security Audit)               ║`));
+  console.log(chalk.bold.cyan(`╚══════════════════════════════════════════════════════════╝\n`));
+
+  const blocked = await enforcer.getBlockedActions(20);
+
+  if (blocked.length === 0) {
+    console.log(chalk.green(`✅ No blocked actions. All operations have been compliant.\n`));
+    return;
+  }
+
+  blocked.forEach((entry, index) => {
+    const timestamp = new Date(entry.timestamp).toLocaleString();
+    console.log(chalk.bold.red(`${index + 1}. BLOCKED ACTION`));
+    console.log(chalk.gray(`   Time: ${timestamp}`));
+    console.log(chalk.gray(`   Current mode: ${entry.currentMode}`));
+    console.log(chalk.gray(`   Required mode: ${entry.requiredMode}`));
+    console.log(chalk.yellow(`   Action: ${entry.action}`));
+    console.log('');
+  });
+
+  console.log(chalk.dim(`Showing last ${blocked.length} blocked actions`));
+  console.log(chalk.red(`⚠️  ${blocked.length} actions were blocked by mode enforcement\n`));
+}
+
+// ==========================================
+// RESET MODE
+// ==========================================
+async function resetMode(enforcer) {
+  console.log(chalk.bold.yellow(`\n[WARNING] Resetting mode to safe default (WORKER mode)...`));
+
+  try {
+    await enforcer.resetMode();
+    console.log(chalk.bold.green(`✅ Mode reset complete`));
+
+    const gate = getGate();
+    await gate.printStatus();
+
+  } catch (error) {
+    console.error(chalk.red(`❌ Reset failed: ${error.message}`));
+    process.exit(1);
+  }
+}

package/bin/onyx-guard.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+/**
+ * ONYX GUARD CLI - Pre-Hook Tool Interceptor
+ *
+ * Executable Node.js wrapper for ONYX tool interception
+ * Can be invoked from command line or programmatically
+ *
+ * USAGE:
+ *   npx onyx-guard --tool Read --file /path/to/file.js
+ *   node onyx-guard.js check Bash
+ *   onyx-guard report
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import onyxInterceptor from '../lib/onyx-tool-interceptor.js';
+
+const program = new Command();
+
+program
+  .name('onyx-guard')
+  .description('ONYX Tool Interceptor - Enforces delegation rules')
+  .version('1.0.0');
+
+/**
+ * Command: check
+ * Check if a tool is allowed for ONYX without executing
+ */
+program
+  .command('check <tool>')
+  .description('Check if tool is allowed for ONYX')
+  .action(async (tool) => {
+    console.log(chalk.blue(`\n🔍 Checking tool: ${tool}`));
+
+    const isForbidden = onyxInterceptor.forbiddenTools.includes(tool);
+    const isAllowed = onyxInterceptor.allowedTools.includes(tool);
+
+    if (isForbidden) {
+      console.log(chalk.red(`❌ FORBIDDEN: ${tool}`));
+      console.log(chalk.dim('ONYX must delegate to Task tool'));
+      process.exit(1);
+    } else if (isAllowed) {
+      console.log(chalk.green(`✅ ALLOWED: ${tool}`));
+      process.exit(0);
+    } else {
+      console.log(chalk.yellow(`⚠️  UNKNOWN: ${tool}`));
+      console.log(chalk.dim('Not in ALLOWED or FORBIDDEN lists'));
+      process.exit(2);
+    }
+  });
+
+/**
+ * Command: intercept
+ * Intercept a tool call and apply delegation rules
+ */
+program
+  .command('intercept <tool>')
+  .description('Intercept tool call and enforce delegation')
+  .option('-p, --params <json>', 'Tool parameters as JSON string', '{}')
+  .option('--auto-delegate', 'Auto-delegate without prompting', false)
+  .option('--silent', 'Silent mode - no prompts', false)
+  .action(async (tool, options) => {
+    let params = {};
+
+    try {
+      params = JSON.parse(options.params);
+    } catch (e) {
+      console.error(chalk.red('Error: Invalid JSON in --params'));
+      process.exit(1);
+    }
+
+    // If silent mode, disable prompts and auto-block
+    if (options.silent) {
+      const isForbidden = onyxInterceptor.forbiddenTools.includes(tool);
+
+      if (isForbidden) {
+        console.log(chalk.red(`❌ BLOCKED: ${tool} (forbidden for ONYX)`));
+        console.log(chalk.yellow('DELEGATE TO: Task tool'));
+        process.exit(1);
+      }
+
+      console.log(chalk.green(`✅ ALLOWED: ${tool}`));
+      process.exit(0);
+    }
+
+    // Full interactive mode
+    const result = await onyxInterceptor.interceptToolCall(tool, params);
+
+    if (!result.allowed) {
+      if (result.delegateTo) {
+        console.log(chalk.cyan(`\n📤 Delegation Required:`));
+        console.log(chalk.white(result.delegationMessage));
+        process.exit(10); // Exit code 10 = delegate
+      }
+
+      if (result.rejected) {
+        console.log(chalk.red('\n❌ Tool call rejected'));
+        process.exit(1);
+      }
+
+      console.log(chalk.red('\n❌ Tool call blocked'));
+      process.exit(1);
+    }
+
+    if (result.override) {
+      console.log(chalk.yellow('\n⚠️  Override granted - violation logged'));
+      process.exit(5); // Exit code 5 = override
+    }
+
+    console.log(chalk.green(`\n✅ Tool call allowed: ${tool}`));
+    process.exit(0);
+  });
+
+/**
+ * Command: report
+ * Print interceptor statistics
+ */
+program
+  .command('report')
+  .description('Print ONYX tool interceptor report')
+  .action(() => {
+    onyxInterceptor.printReport();
+  });
+
+/**
+ * Command: reset
+ * Reset interceptor counters
+ */
+program
+  .command('reset')
+  .description('Reset interceptor counters')
+  .action(() => {
+    onyxInterceptor.reset();
+  });
+
+/**
+ * Command: list
+ * List forbidden/allowed tools
+ */
+program
+  .command('list [type]')
+  .description('List tools (forbidden, allowed, or all)')
+  .action((type = 'all') => {
+    if (type === 'forbidden' || type === 'all') {
+      console.log(chalk.red('\n🚫 FORBIDDEN TOOLS FOR ONYX:'));
+      onyxInterceptor.forbiddenTools.forEach(tool => {
+        console.log(chalk.red(`  ✗ ${tool}`));
+      });
+    }
+
+    if (type === 'allowed' || type === 'all') {
+      console.log(chalk.green('\n✅ ALLOWED TOOLS FOR ONYX:'));
+      onyxInterceptor.allowedTools.forEach(tool => {
+        console.log(chalk.green(`  ✓ ${tool}`));
+      });
+    }
+
+    if (type === 'all') {
+      console.log(chalk.dim('\n📋 DELEGATION RULE:'));
+      console.log(chalk.dim('  ONYX is META-BOSS and NEVER touches files directly'));
+      console.log(chalk.dim('  ONYX delegates to Task tool → Task tool uses file operations'));
+    }
+  });
+
+/**
+ * Command: enable/disable
+ * Enable or disable interceptor
+ */
+program
+  .command('enable')
+  .description('Enable ONYX tool interceptor')
+  .action(() => {
+    onyxInterceptor.setEnabled(true);
+  });
+
+program
+  .command('disable')
+  .description('Disable ONYX tool interceptor')
+  .action(() => {
+    onyxInterceptor.setEnabled(false);
+  });
+
+/**
+ * Command: test
+ * Run test suite for interceptor
+ */
+program
+  .command('test')
+  .description('Test ONYX tool interceptor')
+  .action(async () => {
+    console.log(chalk.blue('\n🧪 Running ONYX Tool Interceptor Tests\n'));
+
+    const tests = [
+      { tool: 'Read', shouldBlock: true },
+      { tool: 'Write', shouldBlock: true },
+      { tool: 'Edit', shouldBlock: true },
+      { tool: 'Bash', shouldBlock: true },
+      { tool: 'Grep', shouldBlock: true },
+      { tool: 'Glob', shouldBlock: true },
+      { tool: 'Task', shouldBlock: false },
+      { tool: 'WebFetch', shouldBlock: false },
+      { tool: 'WebSearch', shouldBlock: false }
+    ];
+
+    // Disable prompts for testing
+    const originalEnabled = onyxInterceptor.enabled;
+    onyxInterceptor.setEnabled(false);
+
+    let passed = 0;
+    let failed = 0;
+
+    tests.forEach(test => {
+      const isForbidden = onyxInterceptor.forbiddenTools.includes(test.tool);
+      const isBlocked = isForbidden;
+
+      const testPassed = isBlocked === test.shouldBlock;
+
+      if (testPassed) {
+        console.log(chalk.green(`✓ ${test.tool}: ${test.shouldBlock ? 'Blocked' : 'Allowed'}`));
+        passed++;
+      } else {
+        console.log(chalk.red(`✗ ${test.tool}: Expected ${test.shouldBlock ? 'block' : 'allow'}, got ${isBlocked ? 'block' : 'allow'}`));
+        failed++;
+      }
+    });
+
+    // Restore original state
+    onyxInterceptor.setEnabled(originalEnabled);
+
+    console.log(chalk.dim('\n─'.repeat(80)));
+    console.log(chalk.white(`Total Tests: ${tests.length}`));
+    console.log(chalk.green(`Passed: ${passed}`));
+    console.log(chalk.red(`Failed: ${failed}`));
+
+    if (failed === 0) {
+      console.log(chalk.green('\n✅ All tests passed!'));
+      process.exit(0);
+    } else {
+      console.log(chalk.red('\n❌ Some tests failed'));
+      process.exit(1);
+    }
+  });
+
+// Parse arguments
+program.parse(process.argv);
+
+// If no command provided, show help
+if (process.argv.length < 3) {
+  program.help();
+}
+
+/**
+ * EXIT CODES:
+ * 0  = Success / Tool allowed
+ * 1  = Error / Tool blocked
+ * 2  = Unknown tool
+ * 5  = Override granted
+ * 10 = Delegation required
+ */