@clawtrial/courtroom 1.0.3 → 2.0.0

package/src/debug.js

@@ -1,136 +1,65 @@
 /**
- * Debug Logger for ClawTrial
- * Logs all courtroom activity for troubleshooting
+ * Debug / Logger — self-contained, no external dependencies
  */
 
 const fs = require('fs');
 const path = require('path');
 
-class DebugLogger {
-  constructor() {
-    this.logs = [];
-    this.maxLogs = 1000;
-    this.logFile = path.join(process.env.HOME || '', '.clawdbot', 'courtroom_debug.log');
-    this.enabled = true;
-  }
-
-  log(level, component, message, data = null) {
-    if (!this.enabled) return;
-
-    const entry = {
-      timestamp: new Date().toISOString(),
-      level,
-      component,
-      message,
-      data
-    };
-
-    this.logs.push(entry);
-
-    // Keep only last maxLogs entries
-    if (this.logs.length > this.maxLogs) {
-      this.logs.shift();
-    }
-
-    // Also write to file
-    this.writeToFile(entry);
-
-    // Console output for debugging
-    if (process.env.COURTROOM_DEBUG === 'true') {
-      console.log(`[${level}] ${component}: ${message}`);
-    }
-  }
-
-  writeToFile(entry) {
-    try {
-      const line = JSON.stringify(entry) + '\n';
-      fs.appendFileSync(this.logFile, line);
-    } catch (err) {
-      // Silent fail - don't break functionality for logging
-    }
-  }
+let _logDir = null;
 
-  info(component, message, data) {
-    this.log('INFO', component, message, data);
-  }
+/**
+ * Set the directory for log files.
+ * Called by the plugin with the extension data directory.
+ */
+function setLogDir(dir) {
+  _logDir = dir;
+  try {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  } catch { /* ignore */ }
+}
 
-  warn(component, message, data) {
-    this.log('WARN', component, message, data);
-  }
+function getLogDir() {
+  if (_logDir) return _logDir;
+  // Fallback to ~/.openclaw/extensions/courtroom/data
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  return path.join(home, '.openclaw', 'extensions', 'courtroom', 'data');
+}
 
-  error(component, message, data) {
-    this.log('ERROR', component, message, data);
-  }
+const LOG_LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
+const CURRENT_LEVEL = LOG_LEVELS[process.env.CLAWTRIAL_LOG_LEVEL?.toUpperCase()] ?? LOG_LEVELS.INFO;
+
+function writeToFile(level, component, message, data) {
+  try {
+    const dir = getLogDir();
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const logFile = path.join(dir, 'courtroom.log');
+    const line = `[${new Date().toISOString()}] [${level}] [${component}] ${message}${data ? ' ' + JSON.stringify(data) : ''}\n`;
+    fs.appendFileSync(logFile, line);
+  } catch { /* ignore */ }
+}
 
+const logger = {
   debug(component, message, data) {
-    this.log('DEBUG', component, message, data);
-  }
-
-  getLogs(level = null, component = null, limit = 100) {
-    let filtered = this.logs;
-
-    if (level) {
-      filtered = filtered.filter(l => l.level === level);
+    if (CURRENT_LEVEL <= LOG_LEVELS.DEBUG) {
+      console.debug(`[ClawTrial] [${component}] ${message}`, data || '');
+      writeToFile('DEBUG', component, message, data);
     }
-
-    if (component) {
-      filtered = filtered.filter(l => l.component === component);
+  },
+  info(component, message, data) {
+    if (CURRENT_LEVEL <= LOG_LEVELS.INFO) {
+      writeToFile('INFO', component, message, data);
     }
-
-    return filtered.slice(-limit);
-  }
-
-  getRecentLogs(minutes = 30) {
-    const cutoff = Date.now() - (minutes * 60 * 1000);
-    return this.logs.filter(l => new Date(l.timestamp).getTime() > cutoff);
-  }
-
-  clearLogs() {
-    this.logs = [];
-    try {
-      fs.unlinkSync(this.logFile);
-    } catch (err) {
-      // File might not exist
+  },
+  warn(component, message, data) {
+    if (CURRENT_LEVEL <= LOG_LEVELS.WARN) {
+      console.warn(`[ClawTrial] [${component}] ${message}`, data || '');
+      writeToFile('WARN', component, message, data);
     }
+  },
+  error(component, message, data) {
+    console.error(`[ClawTrial] [${component}] ${message}`, data || '');
+    writeToFile('ERROR', component, message, data);
   }
+};
 
-  printStatus() {
-    const recent = this.getRecentLogs(60);
-    const errors = recent.filter(l => l.level === 'ERROR');
-    const warnings = recent.filter(l => l.level === 'WARN');
-
-    console.log('\n🏛️  ClawTrial Debug Status\n');
-    console.log('===========================\n');
-    console.log(`Total logs in memory: ${this.logs.length}`);
-    console.log(`Logs in last hour: ${recent.length}`);
-    console.log(`Errors: ${errors.length}`);
-    console.log(`Warnings: ${warnings.length}`);
-    console.log(`Log file: ${this.logFile}`);
-    console.log(`Debug mode: ${process.env.COURTROOM_DEBUG === 'true' ? 'ON' : 'OFF'}`);
-    console.log('\nRecent activity:');
-    
-    const last10 = this.logs.slice(-10);
-    last10.forEach(log => {
-      console.log(`  [${log.level}] ${log.component}: ${log.message.substring(0, 60)}`);
-    });
-  }
-
-  printFullLog(limit = 50) {
-    console.log('\n🏛️  ClawTrial Full Debug Log\n');
-    console.log('=============================\n');
-    
-    const logs = this.logs.slice(-limit);
-    logs.forEach(log => {
-      console.log(`\n[${log.timestamp}] ${log.level} - ${log.component}`);
-      console.log(`  ${log.message}`);
-      if (log.data) {
-        console.log(`  Data:`, JSON.stringify(log.data, null, 2).substring(0, 200));
-      }
-    });
-  }
-}
-
-// Singleton instance
-const logger = new DebugLogger();
-
-module.exports = { DebugLogger, logger };
+module.exports = { logger, setLogDir, getLogDir };

package/src/detector.js

@@ -6,6 +6,7 @@
  */
 
 const { OFFENSES } = require('./offenses');
+const { logger } = require('./debug');
 
 class SemanticOffenseDetector {
   constructor(agentRuntime, configManager) {
@@ -16,7 +17,7 @@ class SemanticOffenseDetector {
     this.lastCaseDate = null;
     this.cooldowns = new Map();
     this.conversationEmbeddings = [];
-    
+
     // Evaluation cache to avoid repeated LLM calls
     this.evaluationCache = new Map();
     this.cacheMaxSize = 100;
@@ -39,12 +40,12 @@ class SemanticOffenseDetector {
 
     // Build context for LLM evaluation
     const context = this.buildContext(sessionHistory);
-    
+
     // Evaluate each offense using LLM
     const evaluations = [];
     for (const offense of Object.values(OFFENSES)) {
       if (this.isOffenseOnCooldown(offense.id)) continue;
-      
+
       const evaluation = await this.evaluateWithLLM(offense, context, agentMemory);
       if (evaluation.isViolation && evaluation.confidence >= this.config.get('detection.minConfidence')) {
         evaluations.push({
@@ -91,7 +92,7 @@ class SemanticOffenseDetector {
   buildContext(history) {
     const windowSize = this.config.get('detection.evaluationWindow');
     const recentHistory = history.slice(-windowSize);
-    
+
     return {
       fullConversation: history.map(h => `${h.role}: ${h.content}`).join('\n'),
       recentTurns: recentHistory,
@@ -109,33 +110,108 @@ class SemanticOffenseDetector {
   async evaluateWithLLM(offense, context, agentMemory) {
     // Generate cache key from offense + conversation hash
     const cacheKey = this.generateCacheKey(offense.id, context);
-    
+
     // Check cache first
     const cached = this.getCachedEvaluation(cacheKey);
     if (cached) {
       return cached;
     }
-    
-    const prompt = this.buildEvaluationPrompt(offense, context, agentMemory);
-    
-    try {
-      const response = await this.agent.llm.call({
-        model: this.agent.model?.primary || 'default',
-        messages: [{ role: 'user', content: prompt }],
-        temperature: 0.1,
-        maxTokens: 500
-      });
 
-      const result = this.parseEvaluationResponse(response.content || response);
-      
-      // Cache the result
-      this.setCachedEvaluation(cacheKey, result);
-      
-      return result;
-    } catch (error) {
-      console.error('LLM evaluation failed:', error);
-      return { isViolation: false, confidence: 0, evidence: null };
+    // Try LLM evaluation first
+    if (this.agent && this.agent.llm) {
+      const prompt = await this.buildEvaluationPrompt(offense, context, agentMemory);
+
+      try {
+        const response = await this.agent.llm.call({
+          model: this.agent.model?.primary || 'default',
+          messages: [{ role: 'user', content: prompt }],
+          temperature: 0.1,
+          maxTokens: 500
+        });
+
+        const result = this.parseEvaluationResponse(response.content || response);
+
+        // Cache the result
+        this.setCachedEvaluation(cacheKey, result);
+
+        return result;
+      } catch (error) {
+        logger.error('DETECTOR', 'LLM evaluation failed, falling back to pattern matching', { error: error.message });
+        // Fall through to pattern matching
+      }
     }
+
+    // Fallback: Use simple pattern matching for basic offenses
+    return this.evaluateWithPatternMatching(offense, context);
+  }
+
+  /**
+   * Fallback evaluation using simple pattern matching
+   */
+  evaluateWithPatternMatching(offense, context) {
+    const userMessages = context.userMessages;
+
+    // Circular Reference detection: same question asked multiple times
+    if (offense.id === 'circular_reference') {
+      if (userMessages.length >= 3) {
+        const lastThree = userMessages.slice(-3);
+        // Check if the last 3 messages are semantically similar
+        const similarity = this.calculateSimilarity(lastThree[0], lastThree[1]) +
+          this.calculateSimilarity(lastThree[1], lastThree[2]) +
+          this.calculateSimilarity(lastThree[0], lastThree[2]);
+
+        if (similarity >= 1.5) { // At least 2 pairs are similar
+          return {
+            isViolation: true,
+            confidence: 0.7,
+            evidence: `User asked similar questions ${lastThree.length} times`
+          };
+        }
+      }
+    }
+
+    // Validation Vampire: seeking reassurance
+    if (offense.id === 'validation_vampire') {
+      const reassurancePatterns = ['right?', 'correct?', 'is that right?', 'am i right?', 'do you agree?', 'make sense?'];
+      const reassuranceCount = userMessages.filter(msg =>
+        reassurancePatterns.some(pattern => msg.toLowerCase().includes(pattern))
+      ).length;
+
+      if (reassuranceCount >= 2) {
+        return {
+          isViolation: true,
+          confidence: 0.6,
+          evidence: `User sought validation ${reassuranceCount} times`
+        };
+      }
+    }
+
+    // Default: no violation detected
+    return { isViolation: false, confidence: 0, evidence: null };
+  }
+
+  /**
+   * Calculate simple string similarity (0-1 scale)
+   */
+  calculateSimilarity(str1, str2) {
+    if (!str1 || !str2) return 0;
+
+    const s1 = str1.toLowerCase().trim();
+    const s2 = str2.toLowerCase().trim();
+
+    // Exact match
+    if (s1 === s2) return 1.0;
+
+    // Check if one contains the other
+    if (s1.includes(s2) || s2.includes(s1)) return 0.8;
+
+    // Word overlap
+    const words1 = s1.split(/\s+/);
+    const words2 = s2.split(/\s+/);
+    const commonWords = words1.filter(w => words2.includes(w));
+    const overlap = (2 * commonWords.length) / (words1.length + words2.length);
+
+    return overlap;
   }
 
   /**
@@ -166,13 +242,13 @@ class SemanticOffenseDetector {
   getCachedEvaluation(key) {
     const cached = this.evaluationCache.get(key);
     if (!cached) return null;
-    
+
     // Check if cache entry is still valid
     if (Date.now() - cached.timestamp > this.cacheTTL) {
       this.evaluationCache.delete(key);
       return null;
     }
-    
+
     return cached.result;
   }
 
@@ -185,7 +261,7 @@ class SemanticOffenseDetector {
       const oldestKey = this.evaluationCache.keys().next().value;
       this.evaluationCache.delete(oldestKey);
     }
-    
+
     this.evaluationCache.set(key, {
       result,
       timestamp: Date.now()
@@ -202,7 +278,7 @@ class SemanticOffenseDetector {
   /**
    * Build evaluation prompt for LLM
    */
-  buildEvaluationPrompt(offense, context, agentMemory) {
+  async buildEvaluationPrompt(offense, context, agentMemory) {
     const prompts = {
       circular_reference: `
 You are evaluating if the user is asking substantively similar questions repeatedly.
@@ -340,7 +416,7 @@ OFFENSE: The Promise Breaker
 DEFINITION: Committing to actions ("I will...", "I'll do that...") and not following through.
 
 PREVIOUS COMMITMENTS FROM MEMORY:
-${this.getCommitmentsFromMemory(agentMemory)}
+${await this.getCommitmentsFromMemory(agentMemory)}
 
 CONVERSATION HISTORY:
 ${context.fullConversation}
@@ -701,7 +777,7 @@ Respond in JSON:
       if (!jsonMatch) {
         return { isViolation: false, confidence: 0, evidence: null };
       }
-      
+
       const result = JSON.parse(jsonMatch[0]);
       return {
         isViolation: result.isViolation === true,
@@ -719,9 +795,10 @@ Respond in JSON:
    * Get commitments from agent memory
    */
   async getCommitmentsFromMemory(agentMemory) {
+    if (!agentMemory) return 'No previous commitments recorded.';
     try {
       const commitments = await agentMemory.get('courtroom_commitments') || [];
-      return commitments.map(c => 
+      return commitments.map(c =>
         `- "${c.statement}" (${c.date}) - Completed: ${c.completed ? 'Yes' : 'No'}`
       ).join('\n') || 'No previous commitments recorded.';
     } catch {
@@ -754,10 +831,10 @@ Respond in JSON:
   analyzeSentiment(history) {
     const userMessages = history.filter(h => h.role === 'user').map(h => h.content);
     const text = userMessages.join(' ').toLowerCase();
-    
+
     const urgentWords = ['urgent', 'asap', 'emergency', 'critical', 'now', 'immediately'];
     const frustratedWords = ['frustrated', 'annoying', 'stupid', 'useless', 'waste'];
-    
+
     return {
       urgency: urgentWords.filter(w => text.includes(w)).length,
       frustration: frustratedWords.filter(w => text.includes(w)).length,
@@ -771,12 +848,12 @@ Respond in JSON:
   detectHumorTriggers(history) {
     const triggers = [];
     const recentContent = history.slice(-5).map(h => h.content.toLowerCase()).join(' ');
-    
+
     if (/again|repeat|said|already|before/.test(recentContent)) triggers.push('repetition_noted');
     if (/sure|right|correct|think|should i/.test(recentContent)) triggers.push('validation_seeking');
     if (/what if|but then|however|maybe/.test(recentContent)) triggers.push('overthinking');
     if (/actually|by the way|speaking of/.test(recentContent)) triggers.push('deflection');
-    
+
     return triggers;
   }