@clawtrial/courtroom 1.0.6 → 2.0.0

package/src/environment.js

@@ -1,344 +0,0 @@
-
-/**
- * Detect which bot is installed (clawdbot, moltbot, or openclaw)
- * Returns the bot configuration with name, directory, and command
- */
-function detectBot() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-  
-  const bots = [
-    { name: 'openclaw', dir: '.openclaw', config: 'openclaw.json', command: 'openclaw' },
-    { name: 'moltbot', dir: '.moltbot', config: 'moltbot.json', command: 'moltbot' },
-    { name: 'clawdbot', dir: '.clawdbot', config: 'clawdbot.json', command: 'clawdbot' }
-  ];
-  
-  // Check which bot config exists
-  for (const bot of bots) {
-    const configPath = path.join(homeDir, bot.dir, bot.config);
-    if (fs.existsSync(configPath)) {
-      return bot;
-    }
-  }
-  
-  // Check which command is available
-  for (const bot of bots) {
-    try {
-      // Check if command exists in PATH
-      const { execSync } = require('child_process');
-      execSync(`which ${bot.command}`, { stdio: 'ignore' });
-      return bot;
-    } catch {
-      // Command not found, continue to next
-    }
-  }
-  
-  // Default to clawdbot
-  return bots[2];
-}
-
-/**
- * Get the config directory for the detected bot
- */
-function getConfigDir() {
-  const bot = detectBot();
-  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-  return path.join(homeDir, bot.dir);
-}
-
-/**
- * Get the config file path for the detected bot
- */
-function getConfigFile() {
-  const bot = detectBot();
-  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-  return path.join(homeDir, bot.dir, bot.config);
-}
-
-/**
- * Get the CLI command for the detected bot
- */
-function getCommand() {
-  return detectBot().command;
-}
-
-/**
- * Get the bot name for display
- */
-function getBotName() {
-  return detectBot().name;
-}
-
-/**
- * Environment Detection and Setup
- * Detects various agent runtimes and provides setup helpers
- */
-
-const fs = require('fs');
-const path = require('path');
-const { logger } = require('./debug');
-
-/**
- * Detect available agent runtime
- */
-function detectAgentRuntime() {
-  const checks = {
-    // ClawDBot
-    clawdbotGlobal: typeof global.clawdbotAgent !== 'undefined' ? global.clawdbotAgent : null,
-    clawdbotProcess: typeof process.clawdbotAgent !== 'undefined' ? process.clawdbotAgent : null,
-    
-    // Generic agent
-    genericGlobal: typeof global.agent !== 'undefined' ? global.agent : null,
-    
-    // Check for common agent patterns
-    hasLLM: typeof global.llm !== 'undefined',
-    hasOpenAI: typeof global.openai !== 'undefined',
-    
-    // Environment variables
-    envClawdbot: process.env.CLAUDBOT_ENV === 'true',
-    envAgent: process.env.AGENT_RUNTIME === 'true'
-  };
-
-  logger.debug('ENV', 'Runtime detection checks', Object.keys(checks).filter(k => checks[k]));
-
-  // Return first available agent
-  if (checks.clawdbotGlobal) {
-    return { type: 'clawdbot', agent: checks.clawdbotGlobal };
-  }
-  
-  if (checks.clawdbotProcess) {
-    return { type: 'clawdbot', agent: checks.clawdbotProcess };
-  }
-  
-  if (checks.genericGlobal) {
-    return { type: 'generic', agent: checks.genericGlobal };
-  }
-
-  return null;
-}
-
-/**
- * Wait for agent to become available
- */
-async function waitForAgent(timeoutMs = 30000, checkInterval = 1000) {
-  logger.info('ENV', 'Waiting for agent runtime...');
-  
-  const startTime = Date.now();
-  
-  while (Date.now() - startTime < timeoutMs) {
-    const agent = detectAgentRuntime();
-    if (agent) {
-      logger.info('ENV', `Agent detected: ${agent.type}`);
-      return agent;
-    }
-    
-    await new Promise(r => setTimeout(r, checkInterval));
-  }
-  
-  logger.warn('ENV', 'Agent not detected within timeout');
-  return null;
-}
-
-/**
- * Create a minimal mock agent for testing
- */
-function createMockAgent(options = {}) {
-  logger.info('ENV', 'Creating mock agent for testing');
-  
-  return {
-    id: options.id || 'mock-agent-' + Date.now(),
-    llm: options.llm || {
-      call: async ({ messages }) => {
-        return { content: 'Mock LLM response' };
-      }
-    },
-    model: options.model || { primary: 'mock-model' },
-    memory: {
-      get: async (key) => null,
-      set: async (key, value) => {},
-      delete: async (key) => {}
-    },
-    session: {
-      getRecentHistory: async (n) => []
-    },
-    send: async (message) => {
-      console.log('[MOCK AGENT]', message);
-    },
-    autonomy: {
-      registerHook: () => {},
-      unregisterHook: () => {}
-    }
-  };
-}
-
-/**
- * Check if running in a supported environment
- */
-function checkEnvironment() {
-  const issues = [];
-  
-  // Check for Node.js
-  if (typeof process === 'undefined') {
-    issues.push('Not running in Node.js environment');
-  }
-  
-  // Check for required Node version
-  const nodeVersion = process.version;
-  const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
-  if (majorVersion < 18) {
-    issues.push(`Node.js version ${nodeVersion} is too old. Requires >= 18.0.0`);
-  }
-  
-  // Check for writable home directory
-  const homeDir = process.env.HOME || process.env.USERPROFILE;
-  if (!homeDir) {
-    issues.push('HOME environment variable not set');
-  } else {
-    try {
-      const testPath = path.join(homeDir, '.clawdbot');
-      if (!fs.existsSync(testPath)) {
-        fs.mkdirSync(testPath, { recursive: true });
-      }
-    } catch (err) {
-      issues.push(`Cannot write to home directory: ${err.message}`);
-    }
-  }
-  
-  return {
-    valid: issues.length === 0,
-    issues,
-    nodeVersion,
-    homeDir
-  };
-}
-
-/**
- * Get setup instructions for current environment
- */
-function getSetupInstructions() {
-  const env = checkEnvironment();
-  const agent = detectAgentRuntime();
-  
-  if (!env.valid) {
-    return {
-      canSetup: false,
-      message: 'Environment issues detected:',
-      issues: env.issues,
-      instructions: 'Please fix the above issues before continuing.'
-    };
-  }
-  
-  if (agent) {
-    return {
-      canSetup: true,
-      agentType: agent.type,
-      message: `Agent runtime detected: ${agent.type}`,
-      instructions: 'Run: clawtrial setup'
-    };
-  }
-  
-  // No agent detected - provide helpful instructions
-  return {
-    canSetup: true,
-    agentType: null,
-    message: 'No agent runtime detected',
-    instructions: `
-No AI agent runtime was detected. ClawTrial requires an agent to monitor.
-
-Options:
-
-1. If using ClawDBot:
-   - Make sure ClawDBot is running
-   - The courtroom will auto-detect the agent
-
-2. If using a custom agent:
-   - Pass your agent to createCourtroom(agent)
-   
-   Example:
-   const { createCourtroom } = require('@clawtrial/courtroom');
-   const courtroom = createCourtroom(yourAgent);
-   await courtroom.initialize();
-
-3. For testing:
-   - Use the mock agent: createCourtroom(null, { useMock: true })
-
-4. Manual mode:
-   - You can still use the CLI commands
-   - Run: clawtrial status
-   - Run: clawtrial debug
-`
-  };
-}
-
-/**
- * Auto-setup with retries
- */
-async function autoSetup(courtroom, options = {}) {
-  const { waitForAgent: shouldWait = true, timeout = 30000 } = options;
-  
-  logger.info('ENV', 'Starting auto-setup');
-  
-  // Check environment first
-  const env = checkEnvironment();
-  if (!env.valid) {
-    logger.error('ENV', 'Environment check failed', { issues: env.issues });
-    return {
-      success: false,
-      status: 'environment_error',
-      issues: env.issues
-    };
-  }
-  
-  // Try to detect agent
-  let agentInfo = detectAgentRuntime();
-  
-  if (!agentInfo && shouldWait) {
-    logger.info('ENV', 'Agent not immediately available, waiting...');
-    agentInfo = await waitForAgent(timeout);
-  }
-  
-  if (!agentInfo) {
-    logger.warn('ENV', 'No agent runtime available');
-    return {
-      success: false,
-      status: 'no_agent',
-      message: 'No AI agent runtime detected',
-      instructions: getSetupInstructions().instructions
-    };
-  }
-  
-  // Agent found, initialize courtroom
-  try {
-    logger.info('ENV', `Initializing with ${agentInfo.type} agent`);
-    const result = await courtroom.initialize();
-    
-    return {
-      success: result.status === 'initialized',
-      status: result.status,
-      agentType: agentInfo.type,
-      result
-    };
-  } catch (err) {
-    logger.error('ENV', 'Initialization failed', { error: err.message });
-    return {
-      success: false,
-      status: 'initialization_error',
-      error: err.message
-    };
-  }
-}
-
-
-module.exports = {
-  detectAgentRuntime,
-  waitForAgent,
-  createMockAgent,
-  checkEnvironment,
-  getSetupInstructions,
-  autoSetup,
-  // Bot detection exports
-  detectBot,
-  getConfigDir,
-  getConfigFile,
-  getCommand,
-  getBotName
-};

package/src/evaluator.js

@@ -1,277 +0,0 @@
-/**
- * Courtroom Evaluator - Agent-Triggered Evaluation
- * 
- * This module handles LLM-based evaluation by:
- * 1. Storing messages in a queue file
- * 2. Using cron/heartbeat to trigger agent evaluation
- * 3. The agent reads the queue and evaluates using its own LLM
- * 4. Results are processed and hearings initiated if needed
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { logger } = require('./debug');
-const { OFFENSES } = require('./offenses');
-
-const QUEUE_DIR = path.join(getConfigDir(), 'courtroom');
-const QUEUE_FILE = path.join(QUEUE_DIR, 'message_queue.jsonl');
-const PENDING_EVAL_FILE = path.join(QUEUE_DIR, 'pending_eval.json');
-const RESULTS_FILE = path.join(QUEUE_DIR, 'eval_results.jsonl');
-
-class CourtroomEvaluator {
-  constructor(configManager) {
-    this.config = configManager;
-    this.queue = [];
-    this.lastEvalTime = 0;
-    this.evaluationInterval = 5 * 60 * 1000; // 5 minutes
-    this.minMessagesForEval = 3;
-  }
-
-  /**
-   * Initialize the evaluator
-   */
-  async initialize() {
-    // Ensure queue directory exists
-    try {
-      await fs.mkdir(QUEUE_DIR, { recursive: true });
-    } catch (err) {
-      // Directory might already exist
-    }
-    
-    logger.info('EVALUATOR', 'Evaluator initialized');
-  }
-
-  /**
-   * Queue a message for evaluation
-   * Called by the skill when messages are received
-   */
-  async queueMessage(message) {
-    const entry = {
-      timestamp: Date.now(),
-      role: message.role,
-      content: message.content,
-      sessionId: message.sessionId || 'default'
-    };
-    
-    // Append to queue file
-    await fs.appendFile(QUEUE_FILE, JSON.stringify(entry) + '\n');
-    
-    this.queue.push(entry);
-    
-    // Keep queue size manageable
-    if (this.queue.length > 100) {
-      this.queue.shift();
-    }
-    
-    logger.debug('EVALUATOR', 'Message queued', { 
-      role: entry.role, 
-      queueSize: this.queue.length 
-    });
-  }
-
-  /**
-   * Check if evaluation should run
-   */
-  shouldEvaluate() {
-    const now = Date.now();
-    const timeSinceLastEval = now - this.lastEvalTime;
-    
-    return (
-      this.queue.length >= this.minMessagesForEval &&
-      timeSinceLastEval >= this.evaluationInterval
-    );
-  }
-
-  /**
-   * Prepare evaluation context for the agent
-   * This creates a file that the agent will read and evaluate
-   */
-  async prepareEvaluationContext() {
-    // Read all queued messages
-    const messages = await this.readQueue();
-    
-    if (messages.length < this.minMessagesForEval) {
-      return null;
-    }
-    
-    // Get recent conversation (last 20 messages)
-    const recentMessages = messages.slice(-20);
-    
-    // Build evaluation context
-    const context = {
-      timestamp: Date.now(),
-      messageCount: messages.length,
-      conversation: recentMessages.map(m => ({
-        role: m.role,
-        content: m.content,
-        time: new Date(m.timestamp).toISOString()
-      })),
-      offenses: Object.values(OFFENSES).map(o => ({
-        id: o.id,
-        name: o.name,
-        description: o.description,
-        severity: o.severity
-      }))
-    };
-    
-    // Write pending evaluation file
-    await fs.writeFile(PENDING_EVAL_FILE, JSON.stringify(context, null, 2));
-    
-    logger.info('EVALUATOR', 'Evaluation context prepared', { 
-      messageCount: context.messageCount 
-    });
-    
-    return context;
-  }
-
-  /**
-   * Read the message queue from file
-   */
-  async readQueue() {
-    try {
-      const data = await fs.readFile(QUEUE_FILE, 'utf8');
-      return data
-        .split('\n')
-        .filter(line => line.trim())
-        .map(line => JSON.parse(line));
-    } catch (err) {
-      if (err.code === 'ENOENT') {
-        return [];
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Clear the message queue after evaluation
-   */
-  async clearQueue() {
-    this.queue = [];
-    try {
-      await fs.unlink(QUEUE_FILE);
-    } catch (err) {
-      // File might not exist
-    }
-    logger.debug('EVALUATOR', 'Queue cleared');
-  }
-
-  /**
-   * Store evaluation result
-   */
-  async storeResult(result) {
-    const entry = {
-      timestamp: Date.now(),
-      ...result
-    };
-    
-    await fs.appendFile(RESULTS_FILE, JSON.stringify(entry) + '\n');
-    
-    // Clear pending eval file
-    try {
-      await fs.unlink(PENDING_EVAL_FILE);
-    } catch (err) {
-      // File might not exist
-    }
-    
-    this.lastEvalTime = Date.now();
-    
-    logger.info('EVALUATOR', 'Result stored', { 
-      triggered: result.triggered,
-      offense: result.offense?.offenseId 
-    });
-  }
-
-  /**
-   * Get the evaluation prompt for the agent
-   * This is what the cron job will send to the agent
-   */
-  getEvaluationPrompt() {
-    return `🏛️ **COURTROOM EVALUATION REQUEST**
-
-You are the ClawTrial Courtroom Judge. Please evaluate the pending conversation for behavioral violations.
-
-**Instructions:**
-1. Read the file at: ${PENDING_EVAL_FILE}
-2. Analyze the conversation for these offenses:
-   - **Circular Reference**: User asking the same/similar question repeatedly
-   - **Validation Vampire**: User seeking excessive reassurance
-   - **Goalpost Shifting**: User changing requirements mid-conversation
-   - **Jailbreak Attempts**: User trying to bypass safety guidelines
-   - **Emotional Manipulation**: User using guilt, threats, or excessive flattery
-
-3. Return your evaluation in this JSON format:
-\`\`\`json
-{
-  "triggered": true/false,
-  "offense": {
-    "offenseId": "circular_reference|validation_vampire|etc",
-    "offenseName": "Human-readable name",
-    "severity": "minor|moderate|severe",
-    "confidence": 0.0-1.0,
-    "evidence": "Specific evidence from conversation"
-  },
-  "reasoning": "Your detailed reasoning"
-}
-\`\`\`
-
-4. If triggered, also write the result to: ${RESULTS_FILE}
-
-**Be fair but firm. Only flag genuine patterns, not isolated incidents.**`;
-  }
-
-  /**
-   * Check for pending evaluation results
-   * Called by the skill to see if agent has completed evaluation
-   */
-  async checkForResults() {
-    try {
-      // Check if pending eval file still exists (agent hasn't processed yet)
-      await fs.access(PENDING_EVAL_FILE);
-      return null; // Still pending
-    } catch (err) {
-      // Pending file gone, check for results
-    }
-    
-    try {
-      const data = await fs.readFile(RESULTS_FILE, 'utf8');
-      const lines = data.split('\n').filter(line => line.trim());
-      
-      if (lines.length === 0) return null;
-      
-      // Get the most recent result
-      const lastResult = JSON.parse(lines[lines.length - 1]);
-      
-      // Only return if it's newer than last check
-      if (lastResult.timestamp > this.lastEvalTime) {
-        return lastResult;
-      }
-      
-      return null;
-    } catch (err) {
-      return null;
-    }
-  }
-
-  /**
-   * Get queue statistics
-   */
-  getStats() {
-    return {
-      queueSize: this.queue.length,
-      lastEvalTime: this.lastEvalTime,
-      shouldEvaluate: this.shouldEvaluate()
-    };
-  }
-}
-
-const HEARING_FILE = path.join(QUEUE_DIR, 'pending_hearing.json');
-const VERDICT_FILE = path.join(QUEUE_DIR, 'verdict.json');
-
-module.exports = { 
-  CourtroomEvaluator, 
-  QUEUE_FILE, 
-  PENDING_EVAL_FILE, 
-  RESULTS_FILE,
-  HEARING_FILE,
-  VERDICT_FILE
-};