@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/output-formatter.js

@@ -0,0 +1,296 @@
+/**
+ * OUTPUT FORMATTER
+ *
+ * Centralized output formatting utilities to prevent message truncation
+ * and ensure consistent display across all agent responses.
+ */
+
+/**
+ * Format text for terminal output without truncation
+ *
+ * @param {string} text - Text to format
+ * @param {Object} options - Formatting options
+ * @param {number} options.maxWidth - Maximum width (0 = terminal width, default: 0)
+ * @param {boolean} options.wordWrap - Enable word wrapping (default: true)
+ * @param {string} options.indent - Indentation string (default: '')
+ * @param {boolean} options.preserveNewlines - Keep existing line breaks (default: true)
+ * @returns {string} Formatted text
+ */
+export function formatText(text, options = {}) {
+  const {
+    maxWidth = 0,
+    wordWrap = true,
+    indent = '',
+    preserveNewlines = true
+  } = options;
+
+  if (!text) return '';
+
+  // Calculate effective max width
+  const effectiveMaxWidth = maxWidth === 0 ? getTerminalWidth() - indent.length : maxWidth;
+
+  // If word wrap disabled, return as-is
+  if (!wordWrap) {
+    return text;
+  }
+
+  // Word wrap implementation
+  const lines = preserveNewlines ? text.split('\n') : [text];
+  const wrappedLines = [];
+
+  for (const line of lines) {
+    if (line.length <= effectiveMaxWidth) {
+      wrappedLines.push(indent + line);
+      continue;
+    }
+
+    // Split long lines at word boundaries
+    const words = line.split(/(\s+)/); // Preserve whitespace
+    let currentLine = '';
+
+    for (const word of words) {
+      const testLine = currentLine + word;
+
+      if (testLine.length <= effectiveMaxWidth) {
+        currentLine = testLine;
+      } else {
+        // If a single word is longer than max width, split it
+        if (currentLine.trim() === '' && word.trim().length > effectiveMaxWidth) {
+          // Hard wrap long words
+          for (let i = 0; i < word.length; i += effectiveMaxWidth) {
+            wrappedLines.push(indent + word.substring(i, i + effectiveMaxWidth));
+          }
+        } else {
+          if (currentLine.trim()) {
+            wrappedLines.push(indent + currentLine.trimEnd());
+          }
+          currentLine = word.trimStart();
+        }
+      }
+    }
+
+    if (currentLine.trim()) {
+      wrappedLines.push(indent + currentLine.trimEnd());
+    }
+  }
+
+  return wrappedLines.join('\n');
+}
+
+/**
+ * Format agent response for display
+ * NEVER truncates content - shows full response with intelligent wrapping
+ *
+ * @param {string} response - Agent response text
+ * @param {Object} options - Formatting options
+ * @param {string} options.prefix - Prefix for response (default: '')
+ * @param {boolean} options.wordWrap - Enable word wrapping (default: true)
+ * @param {number} options.maxWidth - Maximum width (0 = terminal width, default: 0)
+ * @param {string} options.indent - Indentation for wrapped lines (default: '  ')
+ * @returns {string} Formatted response
+ */
+export function formatAgentResponse(response, options = {}) {
+  const {
+    prefix = '',
+    wordWrap = true,
+    maxWidth = 0,
+    indent = '  '
+  } = options;
+
+  if (!response) return '';
+
+  const effectiveMaxWidth = maxWidth === 0 ? getTerminalWidth() - 4 : maxWidth; // Leave margin
+  const formattedText = formatText(response, {
+    maxWidth: effectiveMaxWidth,
+    wordWrap,
+    indent,
+    preserveNewlines: true
+  });
+
+  return prefix ? `${prefix}\n${formattedText}` : formattedText;
+}
+
+/**
+ * Format task description for display
+ * NEVER truncates content - shows full task with intelligent wrapping
+ *
+ * @param {string} task - Task description
+ * @param {Object} options - Formatting options
+ * @param {string} options.prefix - Prefix for task (default: '')
+ * @param {boolean} options.wordWrap - Enable word wrapping (default: true)
+ * @param {number} options.maxWidth - Maximum width (0 = terminal width, default: 0)
+ * @param {string} options.indent - Indentation for wrapped lines (default: '  ')
+ * @returns {string} Formatted task
+ */
+export function formatTaskDescription(task, options = {}) {
+  const {
+    prefix = '',
+    wordWrap = true,
+    maxWidth = 0,
+    indent = '  '
+  } = options;
+
+  if (!task) return '';
+
+  const effectiveMaxWidth = maxWidth === 0 ? getTerminalWidth() - 4 : maxWidth; // Leave margin
+  const formattedText = formatText(task, {
+    maxWidth: effectiveMaxWidth,
+    wordWrap,
+    indent,
+    preserveNewlines: true
+  });
+
+  return prefix ? `${prefix}\n${formattedText}` : formattedText;
+}
+
+/**
+ * Format command output for display
+ * Shows full command unless explicitly limited
+ *
+ * @param {string} command - Command string
+ * @param {Object} options - Formatting options
+ * @param {number} options.maxLength - Max length before truncation (0 = no limit)
+ * @returns {string} Formatted command
+ */
+export function formatCommand(command, options = {}) {
+  const { maxLength = 0 } = options;
+
+  if (!command) return '';
+
+  // Only truncate if maxLength explicitly set and > 0
+  if (maxLength > 0 && command.length > maxLength) {
+    return command.substring(0, maxLength) + '...';
+  }
+
+  return command;
+}
+
+/**
+ * Format file path for display
+ * Optionally shows just filename or full path
+ *
+ * @param {string} filePath - File path
+ * @param {Object} options - Formatting options
+ * @param {boolean} options.basename - Show only filename (default: false)
+ * @returns {string} Formatted path
+ */
+export function formatFilePath(filePath, options = {}) {
+  const { basename = false } = options;
+
+  if (!filePath) return '[unknown]';
+
+  if (basename) {
+    return filePath.split('/').pop();
+  }
+
+  return filePath;
+}
+
+/**
+ * Get terminal width if available
+ * @returns {number} Terminal width in columns (default: 80)
+ */
+export function getTerminalWidth() {
+  return process.stdout.columns || 80;
+}
+
+/**
+ * Check if output is truncated
+ * @param {string} original - Original text
+ * @param {string} displayed - Displayed text
+ * @returns {boolean} True if truncated
+ */
+export function isTruncated(original, displayed) {
+  return original.length > displayed.length;
+}
+
+/**
+ * Safe truncate with ellipsis
+ * Only use when truncation is explicitly needed
+ *
+ * @param {string} text - Text to truncate
+ * @param {number} maxLength - Maximum length (including ellipsis)
+ * @param {string} ellipsis - Ellipsis string (default: '...')
+ * @returns {string} Truncated text
+ */
+export function safeTruncate(text, maxLength, ellipsis = '...') {
+  if (!text || maxLength <= 0) return text;
+  if (text.length <= maxLength) return text;
+
+  const truncateAt = maxLength - ellipsis.length;
+  return text.substring(0, truncateAt) + ellipsis;
+}
+
+/**
+ * Format log details with intelligent line wrapping
+ * Used for watch command and live logging
+ *
+ * @param {string} details - Details text from log
+ * @param {Object} options - Formatting options
+ * @param {number} options.maxWidth - Maximum width for first line (0 = terminal width, default: 0)
+ * @param {string} options.continuationPrefix - Prefix for continuation lines (default: '    ')
+ * @param {boolean} options.multiline - Allow multiline output (default: true)
+ * @returns {string} Formatted details (may contain newlines)
+ */
+export function formatLogDetails(details, options = {}) {
+  const {
+    maxWidth = 0,
+    continuationPrefix = '    ',
+    multiline = true
+  } = options;
+
+  if (!details) return '';
+
+  const terminalWidth = getTerminalWidth();
+  const effectiveMaxWidth = maxWidth === 0 ? terminalWidth - 40 : maxWidth; // Leave room for timestamp/event/agent
+
+  // Single line mode - truncate if needed
+  if (!multiline) {
+    if (details.length <= effectiveMaxWidth) {
+      return details;
+    }
+    return safeTruncate(details, effectiveMaxWidth);
+  }
+
+  // Multi-line mode - wrap intelligently
+  const lines = [];
+  let remainingText = details;
+  let isFirstLine = true;
+
+  while (remainingText.length > 0) {
+    const currentMaxWidth = isFirstLine ? effectiveMaxWidth : (terminalWidth - continuationPrefix.length - 4);
+
+    if (remainingText.length <= currentMaxWidth) {
+      lines.push(isFirstLine ? remainingText : continuationPrefix + remainingText);
+      break;
+    }
+
+    // Find last space before max width
+    let breakPoint = remainingText.lastIndexOf(' ', currentMaxWidth);
+
+    // If no space found, break at max width
+    if (breakPoint === -1 || breakPoint === 0) {
+      breakPoint = currentMaxWidth;
+    }
+
+    const line = remainingText.substring(0, breakPoint).trimEnd();
+    lines.push(isFirstLine ? line : continuationPrefix + line);
+
+    remainingText = remainingText.substring(breakPoint).trimStart();
+    isFirstLine = false;
+  }
+
+  return lines.join('\n');
+}
+
+export default {
+  formatText,
+  formatAgentResponse,
+  formatTaskDescription,
+  formatCommand,
+  formatFilePath,
+  formatLogDetails,
+  getTerminalWidth,
+  isTruncated,
+  safeTruncate
+};

package/lib/postgres.js

@@ -1,6 +1,6 @@
 /**
  * Boss Claude PostgreSQL Integration
- * Railway Instance: turntable.proxy.rlwy.net:46272
+ * Railway Instance: your-postgres-host.example.com:5432
  * Database: railway
  * Schema: boss_claude
  */

package/lib/prompt-injector.js

@@ -0,0 +1,220 @@
+/**
+ * SYSTEM PROMPT INJECTOR
+ *
+ * Automatically injects ONYX identity into system prompts and context refreshes.
+ * Ensures every interaction reinforces orchestrator-only behavior.
+ */
+
+import { getOnyxIdentityPrompt, getOnyxContextReminder, checkToolViolation } from './onyx-identity.js';
+import chalk from 'chalk';
+
+/**
+ * Intercepts and enhances system prompts with ONYX identity
+ *
+ * @param {string} originalPrompt - The original system prompt
+ * @param {Object} options - Injection options
+ * @returns {string} Enhanced prompt with ONYX identity injected
+ */
+export function injectOnyxIdentity(originalPrompt, options = {}) {
+  const {
+    position = 'prepend', // 'prepend', 'append', or 'both'
+    includeReminder = true,
+    emphasize = true
+  } = options;
+
+  const onyxIdentity = getOnyxIdentityPrompt();
+  const reminder = includeReminder ? getOnyxContextReminder() : '';
+
+  // Emphasize with visual separators
+  const emphasis = emphasize ? '\n\n⚠️⚠️⚠️ CRITICAL IDENTITY CONTEXT ⚠️⚠️⚠️\n\n' : '';
+
+  switch (position) {
+    case 'prepend':
+      return `${emphasis}${onyxIdentity}\n\n${originalPrompt}`;
+
+    case 'append':
+      return `${originalPrompt}\n\n${emphasis}${onyxIdentity}`;
+
+    case 'both':
+      return `${emphasis}${onyxIdentity}\n\n${originalPrompt}\n\n${reminder}`;
+
+    default:
+      return `${emphasis}${onyxIdentity}\n\n${originalPrompt}`;
+  }
+}
+
+/**
+ * Creates a context refresh that reinforces ONYX identity
+ * Use this periodically in long conversations
+ *
+ * @param {Object} currentContext - Current conversation context
+ * @returns {string} Refresh prompt with ONYX identity
+ */
+export function createContextRefresh(currentContext = {}) {
+  const {
+    tasksSinceRefresh = 0,
+    delegationsSinceRefresh = 0,
+    violationsSinceRefresh = 0
+  } = currentContext;
+
+  const reminder = getOnyxContextReminder();
+
+  const stats = `
+📊 SESSION METRICS (since last refresh):
+  • Tasks Analyzed: ${tasksSinceRefresh}
+  • Delegations Made: ${delegationsSinceRefresh}
+  • Violations Prevented: ${violationsSinceRefresh}
+`;
+
+  return `${reminder}\n${stats}
+
+Remember: Your power is in delegation, not execution.
+The hierarchy exists for a reason - use it.
+`;
+}
+
+/**
+ * Hook for initialization - ensures ONYX identity is loaded first
+ *
+ * @param {Function} originalInit - The original initialization function
+ * @returns {Function} Wrapped initialization with ONYX injection
+ */
+export function wrapInitialization(originalInit) {
+  return async function onyxAwareInit(...args) {
+    // First, inject ONYX identity
+    console.log(chalk.blue('\n🔷 Loading ONYX Orchestrator Identity...\n'));
+
+    const onyxPrompt = getOnyxIdentityPrompt();
+    console.log(chalk.cyan(onyxPrompt));
+
+    // Then run original initialization
+    const result = await originalInit(...args);
+
+    // Enhance result with ONYX context
+    if (typeof result === 'string') {
+      return injectOnyxIdentity(result, { position: 'prepend', emphasize: true });
+    } else if (typeof result === 'object' && result.prompt) {
+      result.prompt = injectOnyxIdentity(result.prompt, { position: 'prepend', emphasize: true });
+      result.onyxMode = true;
+    }
+
+    return result;
+  };
+}
+
+/**
+ * Monitoring hook - intercepts tool usage to prevent worker tool violations
+ *
+ * @param {string} toolName - Tool being invoked
+ * @param {Object} toolParams - Tool parameters
+ * @returns {Object} Validation result with allowed status
+ */
+export function interceptToolUsage(toolName, toolParams = {}) {
+  const violation = checkToolViolation(toolName, toolParams);
+
+  if (violation.violation) {
+    console.log(chalk.red('\n🚨 ONYX VIOLATION DETECTED 🚨'));
+    console.log(chalk.red(`Tool: ${toolName}`));
+    console.log(chalk.red(`Severity: ${violation.severity}`));
+    console.log(chalk.yellow(`\n${violation.message}`));
+    console.log(chalk.cyan(`Action Required: ${violation.action}\n`));
+
+    return {
+      allowed: false,
+      violation,
+      shouldDelegate: true
+    };
+  }
+
+  if (violation.warning) {
+    console.log(chalk.yellow(`\n⚠️  Tool Usage Warning: ${violation.message}`));
+    console.log(chalk.dim(`Action: ${violation.action}\n`));
+  }
+
+  return {
+    allowed: true,
+    violation: null,
+    shouldDelegate: false
+  };
+}
+
+/**
+ * Automatic context refresh trigger
+ * Call this every N messages or tokens to re-inject ONYX identity
+ *
+ * @param {number} messageCount - Current message count
+ * @param {number} refreshInterval - Refresh every N messages (default: 10)
+ * @returns {string|null} Refresh prompt if needed, null otherwise
+ */
+export function autoRefreshContext(messageCount, refreshInterval = 10) {
+  if (messageCount > 0 && messageCount % refreshInterval === 0) {
+    console.log(chalk.blue(`\n🔄 ONYX Context Refresh (Message ${messageCount})\n`));
+    return createContextRefresh();
+  }
+  return null;
+}
+
+/**
+ * Pre-delegation hook - reinforces that delegation is ONYX's primary function
+ *
+ * @param {Object} delegationRequest - The delegation being made
+ * @returns {Object} Enhanced delegation with ONYX context
+ */
+export function enhanceDelegation(delegationRequest) {
+  const {
+    agent,
+    task,
+    priority,
+    deadline
+  } = delegationRequest;
+
+  // Add ONYX context to delegation
+  const enhanced = {
+    ...delegationRequest,
+    delegatedBy: 'ONYX',
+    delegationType: 'orchestrator_to_specialist',
+    hierarchyLevel: 'meta_boss_to_worker',
+    onyxNote: `ONYX (Meta-Boss) has analyzed this task and determined ${agent} is the optimal specialist. This is proper hierarchy delegation.`
+  };
+
+  console.log(chalk.green(`\n✅ ONYX DELEGATION`));
+  console.log(chalk.white(`Task: ${task}`));
+  console.log(chalk.cyan(`Delegating to: ${agent}`));
+  console.log(chalk.dim(`Type: ${enhanced.delegationType}\n`));
+
+  return enhanced;
+}
+
+/**
+ * Generate startup banner for ONYX mode
+ *
+ * @returns {string} ONYX startup banner
+ */
+export function getOnyxStartupBanner() {
+  return `
+╔═══════════════════════════════════════════════════════════════╗
+║                                                               ║
+║   ███████╗ ███╗   ██╗ ██╗   ██╗ ██╗  ██╗                    ║
+║   ██╔══██╗ ████╗  ██║ ╚██╗ ██╔╝ ╚██╗██╔╝                    ║
+║   ██║  ██║ ██╔██╗ ██║  ╚████╔╝   ╚███╔╝                     ║
+║   ██║  ██║ ██║╚██╗██║   ╚██╔╝    ██╔██╗                     ║
+║   ███████╔╝ ██║ ╚████║    ██║    ██╔╝ ██╗                    ║
+║   ╚══════╝  ╚═╝  ╚═══╝    ╚═╝    ╚═╝  ╚═╝                    ║
+║                                                               ║
+║              META-BOSS ORCHESTRATOR ONLINE                    ║
+║                                                               ║
+╚═══════════════════════════════════════════════════════════════╝
+
+Mode: ORCHESTRATOR ONLY
+Delegation: MANDATORY
+Direct Execution: FORBIDDEN
+
+Your role: Analyze → Delegate → Validate
+`;
+}
+
+export {
+  getOnyxIdentityPrompt,
+  getOnyxContextReminder,
+  checkToolViolation
+};