@cpretzinger/boss-claude 1.0.0 → 1.0.2

package/lib/commentator.js

@@ -0,0 +1,213 @@
+import { watch } from 'fs';
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+import { logAgent } from './agent-logger.js';
+import { getEfficiencyStats } from './session.js';
+
+const TASK_DIR = '/private/tmp/claude/-Users-craigpretzinger-projects-BOSS-claude/tasks';
+const WATCHED_FILES = new Map();
+const MAX_CONTEXT = 200000; // Claude's context window size
+
+function parseActivityLine(line) {
+  try {
+    const json = JSON.parse(line);
+
+    if (json.type === 'user' && json.message?.role === 'user') {
+      const content = json.message.content;
+      if (typeof content === 'string' && content.length > 0) {
+        // NO word wrap here - wrapping happens at display time in watch command
+        // Storing multi-line text in log breaks the log format
+        return `Task: ${content}`;
+      }
+    }
+
+    if (json.type === 'assistant' && json.message?.role === 'assistant') {
+      const content = json.message.content;
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          // Handle text responses (agent output)
+          if (item.type === 'text' && item.text) {
+            // NO word wrap here - wrapping happens at display time in watch command
+            // Storing multi-line text in log breaks the log format
+            return `Response: ${item.text}`;
+          }
+          if (item.type === 'tool_use') {
+            const toolName = item.name;
+            const input = item.input;
+            if (toolName === 'Read' && input?.file_path) {
+              return `Reading: ${input.file_path.split('/').pop()}`;
+            }
+            if (toolName === 'Bash' && input?.description) {
+              return `Exec: ${input.description}`;
+            }
+            if (toolName === 'Write' && input?.file_path) {
+              return `Writing: ${input.file_path.split('/').pop()}`;
+            }
+            if (toolName === 'Edit' && input?.file_path) {
+              return `Editing: ${input.file_path.split('/').pop()}`;
+            }
+            return `Using ${toolName}`;
+          }
+        }
+      }
+    }
+    return null;
+  } catch (err) {
+    return null;
+  }
+}
+
+function checkFileForActivity(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+
+    const currentSize = readFileSync(filePath).length;
+    const lastSize = WATCHED_FILES.get(filePath) || 0;
+
+    if (currentSize <= lastSize) {
+      WATCHED_FILES.set(filePath, currentSize);
+      return null;
+    }
+
+    const content = readFileSync(filePath, 'utf8');
+    const lines = content.split('\n').filter(l => l.trim());
+
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const activity = parseActivityLine(lines[i]);
+      if (activity) {
+        WATCHED_FILES.set(filePath, currentSize);
+        return activity;
+      }
+    }
+
+    WATCHED_FILES.set(filePath, currentSize);
+    return null;
+  } catch (err) {
+    return null;
+  }
+}
+
+function getTokenContextStats() {
+  try {
+    const files = require('fs').readdirSync(TASK_DIR);
+    const outputFiles = files.filter(f => f.endsWith('.output'));
+
+    if (outputFiles.length === 0) return null;
+
+    // Get the most recent output file
+    const latestFile = outputFiles
+      .map(f => ({ name: f, path: join(TASK_DIR, f) }))
+      .sort((a, b) => {
+        try {
+          const statA = require('fs').statSync(a.path);
+          const statB = require('fs').statSync(b.path);
+          return statB.mtimeMs - statA.mtimeMs;
+        } catch {
+          return 0;
+        }
+      })[0];
+
+    if (!latestFile) return null;
+
+    const content = readFileSync(latestFile.path, 'utf8');
+    const lines = content.split('\n').filter(l => l.trim());
+
+    // Look for token budget in system warnings
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const json = JSON.parse(lines[i]);
+        if (json.type === 'system_warning' && json.message) {
+          const match = json.message.match(/Token usage: (\d+)\/(\d+)/);
+          if (match) {
+            const used = parseInt(match[1]);
+            const total = parseInt(match[2]);
+            const percent = ((used / total) * 100).toFixed(1);
+            return { used, total, percent };
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+
+    return null;
+  } catch (err) {
+    return null;
+  }
+}
+
+export function startCommentator() {
+  console.log('🎙️  Commentator active - watching agents...\n');
+
+  if (!existsSync(TASK_DIR)) {
+    console.error(`Task directory not found: ${TASK_DIR}`);
+    return;
+  }
+
+  logAgent('Commentator', 'ACTIVE', 'Monitoring agent output files');
+
+  const watcher = watch(TASK_DIR, { recursive: false }, (eventType, filename) => {
+    if (filename && filename.endsWith('.output')) {
+      const filePath = join(TASK_DIR, filename);
+      const activity = checkFileForActivity(filePath);
+      if (activity) {
+        logAgent('Commentator', 'OBSERVE', activity);
+        console.log(`📢 ${activity}`);
+      }
+    }
+  });
+
+  // Poll efficiency stats every 30 seconds
+  const pollInterval = setInterval(async () => {
+    // Get context stats from task files
+    const contextStats = getTokenContextStats();
+
+    // Get efficiency stats from session
+    let effStats = null;
+    try {
+      effStats = await getEfficiencyStats();
+    } catch (e) {
+      // Redis might not be available
+    }
+
+    console.log('\n' + '─'.repeat(60));
+    console.log('📊 CONDUCTOR DASHBOARD');
+    console.log('─'.repeat(60));
+
+    if (contextStats) {
+      const pct = parseFloat(contextStats.percent);
+      const color = pct < 50 ? '\x1b[32m' : pct < 80 ? '\x1b[33m' : '\x1b[31m';
+      console.log(`   Context: ${color}${contextStats.used.toLocaleString()}/${contextStats.total.toLocaleString()} (${contextStats.percent}%)\x1b[0m`);
+    }
+
+    if (effStats) {
+      const totalTokens = effStats.total_tokens || 0;
+      const onyxPct = totalTokens > 0 ? ((effStats.onyx_tokens / totalTokens) * 100).toFixed(1) : '0.0';
+      const agentPct = totalTokens > 0 ? ((effStats.agent_tokens / totalTokens) * 100).toFixed(1) : '0.0';
+
+      console.log(`   🎺 ONYX:   ${effStats.onyx_tokens.toLocaleString()} tokens (${onyxPct}%)`);
+      console.log(`   🎻 Agents: ${effStats.agent_tokens.toLocaleString()} tokens (${agentPct}%)`);
+      console.log(`   📈 Efficiency: ${effStats.efficiency_ratio}`);
+      console.log(`   🎯 Delegations: ${effStats.delegations}`);
+      console.log(`   💎 Projected XP: +${effStats.projected_bonus_xp + effStats.delegation_bonus_xp}`);
+    } else {
+      console.log('   (Run boss-claude status to initialize tracking)');
+    }
+
+    console.log('─'.repeat(60) + '\n');
+
+    // Log to agent log
+    if (effStats) {
+      logAgent('Commentator', 'STATS', `Efficiency: ${effStats.efficiency_ratio}, Delegations: ${effStats.delegations}`);
+    }
+  }, 30000); // 30 seconds
+
+  process.on('SIGINT', () => {
+    clearInterval(pollInterval);
+    watcher.close();
+    logAgent('Commentator', 'SHUTDOWN', 'Stopped');
+    console.log('\n👋 Commentator stopped');
+    process.exit(0);
+  });
+}

package/lib/context-scribe.js

@@ -0,0 +1,120 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import os from 'os';
+
+const BOSS_DIR = join(os.homedir(), '.boss-claude');
+const SCRIBE_FILE = join(BOSS_DIR, 'current-session.json');
+
+// Ensure directory exists
+try { mkdirSync(BOSS_DIR, { recursive: true }); } catch (e) {}
+
+let scribe = null;
+
+export function initScribe() {
+  scribe = {
+    startTime: Date.now(),
+    decisions: [],
+    filesChanged: [],
+    lessons: [],
+    issuesResolved: [],
+    bugsFound: []
+  };
+  saveScribe();
+  return scribe;
+}
+
+export function getScribe() {
+  if (!scribe && existsSync(SCRIBE_FILE)) {
+    scribe = JSON.parse(readFileSync(SCRIBE_FILE, 'utf8'));
+  }
+  return scribe || initScribe();
+}
+
+function saveScribe() {
+  if (scribe) {
+    writeFileSync(SCRIBE_FILE, JSON.stringify(scribe, null, 2));
+  }
+}
+
+export function logDecision(decision, reasoning = '') {
+  getScribe();
+  scribe.decisions.push({ decision, reasoning, timestamp: Date.now() });
+  saveScribe();
+}
+
+export function logFileChange(filePath, changeType, description = '') {
+  getScribe();
+  scribe.filesChanged.push({ filePath, changeType, description, timestamp: Date.now() });
+  saveScribe();
+}
+
+export function logLesson(lesson, category = 'general') {
+  getScribe();
+  scribe.lessons.push({ lesson, category, timestamp: Date.now() });
+  saveScribe();
+}
+
+export function logIssueResolved(issue, solution) {
+  getScribe();
+  scribe.issuesResolved.push({ issue, solution, timestamp: Date.now() });
+  saveScribe();
+}
+
+export function logBugFound(bug, location, impact = 'medium') {
+  getScribe();
+  scribe.bugsFound.push({ bug, location, impact, timestamp: Date.now() });
+  saveScribe();
+}
+
+export function generateSessionSummary() {
+  const s = getScribe();
+  const duration = Math.round((Date.now() - s.startTime) / 60000);
+
+  let summary = `## Session Overview\nDuration: ${duration} minutes\n\n`;
+
+  if (s.decisions.length) {
+    summary += `### Decisions (${s.decisions.length})\n`;
+    s.decisions.forEach(d => summary += `- ${d.decision}${d.reasoning ? ` (${d.reasoning})` : ''}\n`);
+    summary += '\n';
+  }
+
+  if (s.filesChanged.length) {
+    summary += `### Files Changed (${s.filesChanged.length})\n`;
+    s.filesChanged.forEach(f => summary += `- [${f.changeType}] ${f.filePath}${f.description ? `: ${f.description}` : ''}\n`);
+    summary += '\n';
+  }
+
+  if (s.issuesResolved.length) {
+    summary += `### Issues Resolved (${s.issuesResolved.length})\n`;
+    s.issuesResolved.forEach(i => summary += `- ${i.issue} -> ${i.solution}\n`);
+    summary += '\n';
+  }
+
+  if (s.lessons.length) {
+    summary += `### Lessons Learned (${s.lessons.length})\n`;
+    s.lessons.forEach(l => summary += `- [${l.category}] ${l.lesson}\n`);
+    summary += '\n';
+  }
+
+  return {
+    summary,
+    stats: {
+      duration,
+      decisions: s.decisions.length,
+      filesChanged: s.filesChanged.length,
+      issuesResolved: s.issuesResolved.length,
+      lessons: s.lessons.length
+    }
+  };
+}
+
+export function clearScribe() {
+  scribe = null;
+  if (existsSync(SCRIBE_FILE)) {
+    writeFileSync(SCRIBE_FILE, '{}');
+  }
+}
+
+export function exportScribe() {
+  return JSON.stringify(getScribe(), null, 2);
+}

package/lib/delegation-strategies.js

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+/**
+ * DELEGATION STRATEGIES
+ *
+ * Defines auto-delegation strategies for different tool types.
+ * Determines when to delegate vs. when to allow direct execution.
+ */
+
+/**
+ * Tool categories for delegation
+ */
+export const TOOL_CATEGORIES = {
+  // Always delegate to Task agent
+  FILE_OPS: ['Read', 'Write', 'Edit', 'NotebookEdit'],
+  SEARCH_OPS: ['Grep', 'Glob'],
+  EXEC_OPS: ['Bash'],
+
+  // Sometimes delegate based on complexity
+  CONDITIONAL: ['WebFetch', 'WebSearch'],
+
+  // Never delegate - ONYX can use directly
+  ALLOWED: ['Task', 'TodoWrite', 'Skill']
+};
+
+/**
+ * Complexity thresholds for conditional delegation
+ */
+const COMPLEXITY_THRESHOLDS = {
+  // File operations
+  file_read_lines: 500,        // Auto-delegate reads >500 lines
+  file_write_lines: 100,       // Auto-delegate writes >100 lines
+
+  // Search operations
+  grep_results: 50,            // Auto-delegate if expected >50 results
+  glob_patterns: 10,           // Auto-delegate complex glob patterns
+
+  // Bash operations
+  bash_command_length: 100,    // Auto-delegate long commands
+  bash_piped_commands: 2       // Auto-delegate if >2 pipes
+};
+
+/**
+ * Determine if tool should be delegated
+ *
+ * @param {string} toolName - Name of tool
+ * @param {Object} toolParams - Tool parameters
+ * @param {Object} context - Execution context
+ * @returns {Object} { shouldDelegate: boolean, reason: string, strategy: string }
+ */
+export function shouldDelegateTool(toolName, toolParams = {}, context = {}) {
+  const agentName = context.agentName || 'Unknown';
+
+  // ONYX agents ALWAYS delegate file/search/exec operations
+  const isOnyxAgent = agentName.toUpperCase().includes('ONYX') ||
+                     agentName === 'BOSS' ||
+                     agentName === 'META-BOSS';
+
+  // Check if tool is in always-delegate categories
+  const isFileOp = TOOL_CATEGORIES.FILE_OPS.includes(toolName);
+  const isSearchOp = TOOL_CATEGORIES.SEARCH_OPS.includes(toolName);
+  const isExecOp = TOOL_CATEGORIES.EXEC_OPS.includes(toolName);
+  const isAllowed = TOOL_CATEGORIES.ALLOWED.includes(toolName);
+
+  // Allowed tools - never delegate
+  if (isAllowed) {
+    return {
+      shouldDelegate: false,
+      reason: `${toolName} is allowed for ${agentName}`,
+      strategy: 'ALLOWED'
+    };
+  }
+
+  // ONYX agents - auto-delegate file/search/exec
+  if (isOnyxAgent) {
+    if (isFileOp || isSearchOp || isExecOp) {
+      return {
+        shouldDelegate: true,
+        reason: `${agentName} must delegate ${toolName} to Task agent`,
+        strategy: 'ONYX_AUTO_DELEGATE',
+        delegateTo: 'Task'
+      };
+    }
+  }
+
+  // Non-ONYX agents - check complexity thresholds
+  if (isFileOp) {
+    const complexity = analyzeFileOpComplexity(toolName, toolParams);
+    if (complexity.shouldDelegate) {
+      return {
+        shouldDelegate: true,
+        reason: `File operation too complex: ${complexity.reason}`,
+        strategy: 'COMPLEXITY_THRESHOLD',
+        delegateTo: 'Task',
+        complexity
+      };
+    }
+  }
+
+  if (isSearchOp) {
+    const complexity = analyzeSearchOpComplexity(toolName, toolParams);
+    if (complexity.shouldDelegate) {
+      return {
+        shouldDelegate: true,
+        reason: `Search operation too complex: ${complexity.reason}`,
+        strategy: 'COMPLEXITY_THRESHOLD',
+        delegateTo: 'Task',
+        complexity
+      };
+    }
+  }
+
+  if (isExecOp) {
+    const complexity = analyzeExecOpComplexity(toolName, toolParams);
+    if (complexity.shouldDelegate) {
+      return {
+        shouldDelegate: true,
+        reason: `Bash operation too complex: ${complexity.reason}`,
+        strategy: 'COMPLEXITY_THRESHOLD',
+        delegateTo: 'Task',
+        complexity
+      };
+    }
+  }
+
+  // Default: allow execution
+  return {
+    shouldDelegate: false,
+    reason: 'Below complexity threshold',
+    strategy: 'ALLOW_DIRECT'
+  };
+}
+
+/**
+ * Analyze file operation complexity
+ */
+function analyzeFileOpComplexity(toolName, params) {
+  const result = {
+    shouldDelegate: false,
+    reason: '',
+    score: 0
+  };
+
+  if (toolName === 'Read') {
+    // Check if file is large (via limit param)
+    if (params.limit && params.limit > COMPLEXITY_THRESHOLDS.file_read_lines) {
+      result.shouldDelegate = true;
+      result.reason = `Reading ${params.limit} lines (threshold: ${COMPLEXITY_THRESHOLDS.file_read_lines})`;
+      result.score = 2;
+    }
+  }
+
+  if (toolName === 'Write') {
+    // Check content length (both line count and character count)
+    const content = params.content || '';
+    const lineCount = content.split('\n').length;
+    const charCount = content.length;
+
+    if (lineCount > COMPLEXITY_THRESHOLDS.file_write_lines) {
+      result.shouldDelegate = true;
+      result.reason = `Writing ${lineCount} lines (threshold: ${COMPLEXITY_THRESHOLDS.file_write_lines})`;
+      result.score = 2;
+    } else if (charCount > 5000) {
+      // Large single-line content
+      result.shouldDelegate = true;
+      result.reason = `Writing large content (${charCount} chars)`;
+      result.score = 2;
+    }
+  }
+
+  if (toolName === 'Edit') {
+    // Check if large replacement
+    const oldLength = (params.old_string || '').length;
+    const newLength = (params.new_string || '').length;
+    if (oldLength > 500 || newLength > 500) {
+      result.shouldDelegate = true;
+      result.reason = `Large edit operation (${Math.max(oldLength, newLength)} chars)`;
+      result.score = 2;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Analyze search operation complexity
+ */
+function analyzeSearchOpComplexity(toolName, params) {
+  const result = {
+    shouldDelegate: false,
+    reason: '',
+    score: 0
+  };
+
+  if (toolName === 'Grep') {
+    // Check if complex regex pattern
+    const pattern = params.pattern || '';
+    const hasAdvancedRegex = /[\[\]\{\}\(\)\|\\\^\$\*\+\?]/.test(pattern);
+    const isMultiline = params.multiline === true;
+
+    if (hasAdvancedRegex && isMultiline) {
+      result.shouldDelegate = true;
+      result.reason = 'Complex regex with multiline mode';
+      result.score = 2;
+    }
+  }
+
+  if (toolName === 'Glob') {
+    // Check pattern complexity
+    const pattern = params.pattern || '';
+    const hasMultipleWildcards = (pattern.match(/\*\*/g) || []).length > 2;
+    const hasComplexBraces = /\{[^}]+,[^}]+\}/.test(pattern);
+
+    if (hasMultipleWildcards || hasComplexBraces) {
+      result.shouldDelegate = true;
+      result.reason = 'Complex glob pattern with multiple wildcards';
+      result.score = 2;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Analyze execution operation complexity
+ */
+function analyzeExecOpComplexity(toolName, params) {
+  const result = {
+    shouldDelegate: false,
+    reason: '',
+    score: 0
+  };
+
+  if (toolName === 'Bash') {
+    const command = params.command || '';
+
+    // Check command length
+    if (command.length > COMPLEXITY_THRESHOLDS.bash_command_length) {
+      result.shouldDelegate = true;
+      result.reason = `Long command (${command.length} chars)`;
+      result.score = 2;
+    }
+
+    // Check for pipes
+    const pipeCount = (command.match(/\|/g) || []).length;
+    if (pipeCount > COMPLEXITY_THRESHOLDS.bash_piped_commands) {
+      result.shouldDelegate = true;
+      result.reason = `Complex piped command (${pipeCount} pipes)`;
+      result.score = 2;
+    }
+
+    // Check for dangerous operations
+    const hasDangerousOps = /rm -rf|dd |mkfs|format|:(){:|fork/.test(command);
+    if (hasDangerousOps) {
+      result.shouldDelegate = true;
+      result.reason = 'Potentially dangerous operation detected';
+      result.score = 3;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Generate delegation message for Task tool
+ */
+export function generateDelegationMessage(toolName, toolParams, decision) {
+  const messages = {
+    Read: `Read file: ${toolParams.file_path || '[file_path]'}${toolParams.limit ? ` (${toolParams.limit} lines)` : ''}`,
+    Write: `Write to file: ${toolParams.file_path || '[file_path]'}`,
+    Edit: `Edit file: ${toolParams.file_path || '[file_path]'}`,
+    Bash: `Execute command: ${toolParams.command || ''}`,
+    Grep: `Search for pattern "${toolParams.pattern || '[pattern]'}" ${toolParams.path ? `in ${toolParams.path}` : 'in codebase'}`,
+    Glob: `Find files matching "${toolParams.pattern || '[pattern]'}"`
+  };
+
+  const baseMessage = messages[toolName] || `Execute ${toolName} operation`;
+  const reason = decision.reason || 'Auto-delegation by Tool Wrapper';
+
+  return {
+    description: `AUTO-DELEGATED: ${baseMessage}`,
+    details: reason,
+    originalTool: toolName,
+    originalParams: toolParams,
+    strategy: decision.strategy
+  };
+}
+
+/**
+ * Get delegation statistics
+ */
+export function getDelegationStats(delegationLog = []) {
+  const stats = {
+    total: delegationLog.length,
+    delegated: 0,
+    direct: 0,
+    byStrategy: {},
+    byTool: {},
+    delegationRate: 0
+  };
+
+  delegationLog.forEach(entry => {
+    if (entry.delegated) {
+      stats.delegated++;
+      const strategy = entry.strategy || 'UNKNOWN';
+      stats.byStrategy[strategy] = (stats.byStrategy[strategy] || 0) + 1;
+    } else {
+      stats.direct++;
+    }
+
+    const tool = entry.tool || 'UNKNOWN';
+    stats.byTool[tool] = (stats.byTool[tool] || 0) + 1;
+  });
+
+  stats.delegationRate = stats.total > 0
+    ? (stats.delegated / stats.total * 100).toFixed(2)
+    : 0;
+
+  return stats;
+}
+
+export default {
+  TOOL_CATEGORIES,
+  shouldDelegateTool,
+  generateDelegationMessage,
+  getDelegationStats
+};