@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/onyx-reminder.js

@@ -0,0 +1,188 @@
+import Redis from 'ioredis';
+import dotenv from 'dotenv';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import os from 'os';
+import chalk from 'chalk';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load environment variables from ~/.boss-claude/.env
+const envPath = join(os.homedir(), '.boss-claude', '.env');
+if (existsSync(envPath)) {
+  dotenv.config({ path: envPath });
+}
+
+let redis = null;
+
+function getRedis() {
+  if (!redis) {
+    if (!process.env.REDIS_URL) {
+      throw new Error('REDIS_URL not found. Please run: boss-claude init');
+    }
+    redis = new Redis(process.env.REDIS_URL);
+  }
+  return redis;
+}
+
+const REMINDER_KEY = 'boss:onyx:message_count';
+const DEFAULT_INTERVAL = 5; // Show reminder every 5 messages
+
+/**
+ * Increment message counter and check if reminder should be displayed
+ * @param {number} interval - Number of messages between reminders (default: 5)
+ * @returns {Promise<{shouldShow: boolean, count: number, reminder: string|null}>}
+ */
+export async function checkOnyxReminder(interval = DEFAULT_INTERVAL) {
+  try {
+    const client = getRedis();
+
+    // Increment counter
+    const count = await client.incr(REMINDER_KEY);
+
+    // Check if we should show reminder
+    const shouldShow = count % interval === 0;
+
+    let reminder = null;
+    if (shouldShow) {
+      reminder = formatReminder(count);
+    }
+
+    return {
+      shouldShow,
+      count,
+      reminder
+    };
+  } catch (error) {
+    console.error('ONYX Reminder Error:', error.message);
+    return {
+      shouldShow: false,
+      count: 0,
+      reminder: null
+    };
+  }
+}
+
+/**
+ * Format the ONYX reminder message
+ * @param {number} count - Current message count
+ * @returns {string}
+ */
+function formatReminder(count) {
+  return `
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⚡ CRITICAL REMINDER ⚡
+
+${chalk.bold.red('ONYX = ORCHESTRATOR ONLY')}
+
+${chalk.yellow('ONYX must NEVER execute tasks directly.')}
+${chalk.yellow('ONYX must ALWAYS delegate to specialized engineers.')}
+
+Message Count: ${count}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`;
+}
+
+/**
+ * Reset the message counter (useful for new sessions)
+ * @returns {Promise<void>}
+ */
+export async function resetOnyxCounter() {
+  try {
+    const client = getRedis();
+    await client.del(REMINDER_KEY);
+  } catch (error) {
+    console.error('Error resetting ONYX counter:', error.message);
+  }
+}
+
+/**
+ * Get current message count
+ * @returns {Promise<number>}
+ */
+export async function getOnyxMessageCount() {
+  try {
+    const client = getRedis();
+    const count = await client.get(REMINDER_KEY);
+    return parseInt(count || '0', 10);
+  } catch (error) {
+    console.error('Error getting ONYX count:', error.message);
+    return 0;
+  }
+}
+
+/**
+ * Set custom interval for reminders
+ * @param {number} interval - Number of messages between reminders
+ * @returns {Promise<void>}
+ */
+export async function setOnyxInterval(interval) {
+  try {
+    const client = getRedis();
+    await client.set('boss:onyx:interval', interval);
+  } catch (error) {
+    console.error('Error setting ONYX interval:', error.message);
+  }
+}
+
+/**
+ * Get current reminder interval
+ * @returns {Promise<number>}
+ */
+export async function getOnyxInterval() {
+  try {
+    const client = getRedis();
+    const interval = await client.get('boss:onyx:interval');
+    return parseInt(interval || DEFAULT_INTERVAL.toString(), 10);
+  } catch (error) {
+    console.error('Error getting ONYX interval:', error.message);
+    return DEFAULT_INTERVAL;
+  }
+}
+
+/**
+ * Auto-hook for Claude Code - Call this after every message
+ * This is the main function to integrate into conversation flow
+ * @param {number} customInterval - Optional custom interval
+ * @returns {Promise<string|null>}
+ */
+export async function onyxAutoReminder(customInterval = null) {
+  try {
+    const interval = customInterval || await getOnyxInterval();
+    const { shouldShow, reminder } = await checkOnyxReminder(interval);
+
+    if (shouldShow && reminder) {
+      console.log(reminder);
+      return reminder;
+    }
+
+    return null;
+  } catch (error) {
+    console.error('ONYX Auto-Reminder Error:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Manual trigger - Force display the reminder
+ * @returns {Promise<string>}
+ */
+export async function showOnyxReminder() {
+  const count = await getOnyxMessageCount();
+  const reminder = formatReminder(count);
+  console.log(reminder);
+  return reminder;
+}
+
+// Export for CLI usage
+export default {
+  checkOnyxReminder,
+  resetOnyxCounter,
+  getOnyxMessageCount,
+  setOnyxInterval,
+  getOnyxInterval,
+  onyxAutoReminder,
+  showOnyxReminder
+};

package/lib/onyx-tool-interceptor.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+/**
+ * ONYX TOOL INTERCEPTOR - Pre-Hook System
+ *
+ * Automatically intercepts Read/Write/Edit/Bash/Grep/Glob tool calls
+ * and blocks them, forcing delegation to Task tool instead.
+ *
+ * EXECUTABLE CODE - Not documentation
+ */
+
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+// Define ONYX agent name
+const ONYX_AGENT = 'ONYX';
+
+// Tools forbidden for ONYX (must delegate instead)
+const FORBIDDEN_TOOLS = [
+  'Read',
+  'Write',
+  'Edit',
+  'Bash',
+  'Grep',
+  'Glob',
+  'NotebookEdit'
+];
+
+// ONYX is allowed to use these tools
+const ALLOWED_TOOLS = [
+  'Task',           // Primary delegation tool
+  'WebFetch',       // Research allowed
+  'WebSearch',      // Research allowed
+  'TodoWrite',      // Planning allowed
+  'Skill'           // Can invoke skills
+];
+
+/**
+ * ONYX Tool Interceptor Class
+ * Hooks into tool calls and enforces delegation rules
+ */
+export class OnyxToolInterceptor {
+  constructor(config = {}) {
+    this.agentName = config.agentName || ONYX_AGENT;
+    this.forbiddenTools = config.forbiddenTools || FORBIDDEN_TOOLS;
+    this.allowedTools = config.allowedTools || ALLOWED_TOOLS;
+    this.violations = [];
+    this.blockCount = 0;
+    this.delegationCount = 0;
+    this.enabled = true;
+  }
+
+  /**
+   * PRE-HOOK: Intercept tool call before execution
+   * Returns { allowed: boolean, reason: string, delegateTo?: string }
+   */
+  async interceptToolCall(toolName, toolParams = {}) {
+    if (!this.enabled) {
+      return { allowed: true, reason: 'Interceptor disabled' };
+    }
+
+    // Check if this is ONYX agent
+    if (this.agentName !== ONYX_AGENT) {
+      return { allowed: true, reason: 'Not ONYX agent - no restrictions' };
+    }
+
+    // Check if tool is forbidden
+    const isForbidden = this.forbiddenTools.includes(toolName);
+    const isAllowed = this.allowedTools.includes(toolName);
+
+    if (isForbidden) {
+      this.blockCount++;
+
+      console.log(chalk.red('\n🚨 ONYX TOOL BLOCK TRIGGERED'));
+      console.log(chalk.dim('═'.repeat(80)));
+      console.log(chalk.white(`Agent: ${chalk.bold(this.agentName)}`));
+      console.log(chalk.white(`Forbidden Tool: ${chalk.red(toolName)}`));
+      console.log(chalk.white(`Params: ${chalk.dim(JSON.stringify(toolParams, null, 2))}`));
+
+      console.log(chalk.yellow('\n📋 ONYX 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'));
+      console.log(chalk.red(`  FORBIDDEN: ONYX → ${toolName} (direct file access)`));
+      console.log(chalk.green(`  ALLOWED: ONYX → Task → ${toolName} (delegated access)`));
+
+      console.log(chalk.dim('\n═'.repeat(80)));
+
+      // Generate delegation message
+      const delegationMessage = this._generateDelegationMessage(toolName, toolParams);
+
+      // Prompt user for action
+      const action = await this._promptBlockedAction(toolName, delegationMessage);
+
+      if (action.action === 'delegate') {
+        this.delegationCount++;
+        console.log(chalk.green('\n✅ Delegating to Task tool...'));
+        console.log(chalk.dim(`Message: ${delegationMessage}`));
+
+        return {
+          allowed: false,
+          blocked: true,
+          reason: 'ONYX cannot use file tools directly - must delegate to Task',
+          delegateTo: 'Task',
+          delegationMessage,
+          toolName,
+          toolParams
+        };
+      }
+
+      if (action.action === 'override') {
+        // Log violation but allow
+        this._recordViolation(toolName, toolParams, action.justification);
+
+        console.log(chalk.yellow('\n⚠️  Override granted - violation logged'));
+        console.log(chalk.dim(`Justification: ${action.justification}`));
+
+        return {
+          allowed: true,
+          override: true,
+          reason: `Override: ${action.justification}`,
+          violation: true
+        };
+      }
+
+      if (action.action === 'reject') {
+        console.log(chalk.red('\n❌ Tool call rejected - ONYX must delegate'));
+
+        return {
+          allowed: false,
+          blocked: true,
+          rejected: true,
+          reason: 'ONYX delegation rule violation - must use Task tool'
+        };
+      }
+    }
+
+    if (isAllowed) {
+      // Tool is explicitly allowed for ONYX
+      return {
+        allowed: true,
+        reason: `${toolName} is allowed for ONYX`
+      };
+    }
+
+    // Unknown tool - allow but warn
+    console.log(chalk.yellow(`\n⚠️  Unknown tool for ONYX: ${toolName}`));
+    console.log(chalk.dim('Allowing by default - add to ALLOWED_TOOLS or FORBIDDEN_TOOLS'));
+
+    return {
+      allowed: true,
+      reason: 'Unknown tool - allowed by default',
+      warning: true
+    };
+  }
+
+  /**
+   * Generate Task tool delegation message
+   */
+  _generateDelegationMessage(toolName, toolParams) {
+    const messages = {
+      Read: `Read the file at ${toolParams.file_path || '[file_path]'}`,
+      Write: `Write content to ${toolParams.file_path || '[file_path]'}`,
+      Edit: `Edit ${toolParams.file_path || '[file_path]'} - replace "${(toolParams.old_string || '').substring(0, 50)}..." with new content`,
+      Bash: `Execute bash command: ${toolParams.command || '[command]'}`,
+      Grep: `Search for pattern "${toolParams.pattern || '[pattern]'}" in codebase`,
+      Glob: `Find files matching pattern "${toolParams.pattern || '[pattern]'}"`
+    };
+
+    const baseMessage = messages[toolName] || `Execute ${toolName} tool`;
+
+    return `ONYX DELEGATION: ${baseMessage}\n\nReason: ONYX is meta-boss and delegates file operations to specialist agents.`;
+  }
+
+  /**
+   * Prompt user when tool is blocked
+   */
+  async _promptBlockedAction(toolName, delegationMessage) {
+    const choices = [
+      {
+        name: `✅ Delegate to Task tool (RECOMMENDED)`,
+        value: 'delegate',
+        short: 'Delegate'
+      },
+      {
+        name: `⚠️  Override: Allow ONYX to use ${toolName} (logs violation)`,
+        value: 'override',
+        short: 'Override'
+      },
+      {
+        name: `❌ Reject: Block this operation entirely`,
+        value: 'reject',
+        short: 'Reject'
+      }
+    ];
+
+    const answer = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'action',
+        message: chalk.bold(`ONYX attempted to use ${chalk.red(toolName)}. How to proceed?`),
+        choices,
+        default: 0
+      }
+    ]);
+
+    if (answer.action === 'override') {
+      const justification = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'justification',
+          message: chalk.yellow('Provide justification for override (will be logged):'),
+          validate: (input) => {
+            if (input.length < 20) {
+              return 'Justification must be at least 20 characters';
+            }
+            return true;
+          }
+        }
+      ]);
+
+      return {
+        action: 'override',
+        justification: justification.justification
+      };
+    }
+
+    return { action: answer.action };
+  }
+
+  /**
+   * Record violation for audit trail
+   */
+  _recordViolation(toolName, toolParams, justification) {
+    const violation = {
+      timestamp: new Date().toISOString(),
+      agent: this.agentName,
+      tool: toolName,
+      params: toolParams,
+      justification,
+      severity: 'medium'
+    };
+
+    this.violations.push(violation);
+
+    return violation;
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return {
+      blockCount: this.blockCount,
+      delegationCount: this.delegationCount,
+      violationCount: this.violations.length,
+      complianceRate: this.delegationCount / (this.delegationCount + this.violations.length) * 100 || 0,
+      violations: this.violations
+    };
+  }
+
+  /**
+   * Print report
+   */
+  printReport() {
+    const stats = this.getStats();
+
+    console.log(chalk.blue('\n📊 ONYX TOOL INTERCEPTOR REPORT'));
+    console.log(chalk.dim('═'.repeat(80)));
+    console.log(chalk.white(`Total Blocks: ${chalk.magenta(stats.blockCount)}`));
+    console.log(chalk.white(`Delegations: ${chalk.green(stats.delegationCount)}`));
+    console.log(chalk.white(`Violations: ${chalk.red(stats.violationCount)}`));
+    console.log(chalk.white(`Compliance Rate: ${chalk.cyan(stats.complianceRate.toFixed(1) + '%')}`));
+    console.log(chalk.dim('═'.repeat(80)));
+
+    if (stats.violations.length > 0) {
+      console.log(chalk.yellow('\n⚠️  VIOLATIONS:'));
+      stats.violations.forEach((v, i) => {
+        console.log(chalk.dim(`\n${i + 1}. ${v.tool} - ${v.timestamp}`));
+        console.log(chalk.dim(`   Justification: ${v.justification}`));
+      });
+    }
+  }
+
+  /**
+   * Enable/disable interceptor
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    console.log(chalk.cyan(`\nONYX Tool Interceptor: ${enabled ? 'ENABLED' : 'DISABLED'}`));
+  }
+
+  /**
+   * Reset counters
+   */
+  reset() {
+    this.blockCount = 0;
+    this.delegationCount = 0;
+    this.violations = [];
+    console.log(chalk.green('\n✅ ONYX Tool Interceptor reset'));
+  }
+}
+
+// Singleton instance
+const interceptor = new OnyxToolInterceptor();
+
+export default interceptor;
+
+/**
+ * INTEGRATION EXAMPLE:
+ *
+ * // In ONYX agent wrapper or Claude Code integration:
+ *
+ * import onyxInterceptor from '@cpretzinger/boss-claude/lib/onyx-tool-interceptor.js';
+ *
+ * async function executeToolCall(toolName, toolParams) {
+ *   // PRE-HOOK: Intercept before execution
+ *   const result = await onyxInterceptor.interceptToolCall(toolName, toolParams);
+ *
+ *   if (!result.allowed) {
+ *     if (result.delegateTo === 'Task') {
+ *       // Auto-delegate to Task tool
+ *       return await executeTaskTool({
+ *         description: result.delegationMessage,
+ *         context: { originalTool: toolName, originalParams: toolParams }
+ *       });
+ *     }
+ *
+ *     // Tool call blocked
+ *     throw new Error(result.reason);
+ *   }
+ *
+ *   if (result.override) {
+ *     console.warn('ONYX delegation override - violation logged');
+ *   }
+ *
+ *   // Execute original tool
+ *   return await executeTool(toolName, toolParams);
+ * }
+ *
+ * // Print report at end of session
+ * onyxInterceptor.printReport();
+ */