@cloudstreamsoftware/claude-tools 1.0.0 → 1.1.0

package/scripts/hooks/quality-gate-enforcer.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+
+/**
+ * Quality Gate Enforcer Hook
+ *
+ * Enforces quality gates on Edit/Write operations.
+ * Gates can warn, block, or require confirmation based on severity.
+ *
+ * Hook Type: PreToolUse (Edit, Write, Bash for git commit)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { readStdinJson, log, output, getClaudeDir, readFile } = require('../lib/utils');
+
+// Load gate configuration
+const GATES_CONFIG_PATH = path.join(__dirname, '..', '..', 'config', 'quality-gates.json');
+
+/**
+ * Load quality gates configuration
+ */
+function loadGatesConfig() {
+  try {
+    const content = fs.readFileSync(GATES_CONFIG_PATH, 'utf8');
+    return JSON.parse(content);
+  } catch (err) {
+    log(`[QualityGate] Error loading config: ${err.message}`);
+    return { gates: {}, enforcement: { currentPhase: 'warn_all' } };
+  }
+}
+
+/**
+ * Get current compliance mode from environment or session
+ */
+function getComplianceMode() {
+  // Check environment variable first
+  if (process.env.CLOUDSTREAM_COMPLIANCE_MODE) {
+    return process.env.CLOUDSTREAM_COMPLIANCE_MODE.toLowerCase();
+  }
+
+  // Try to read from session memory
+  try {
+    const memoryPath = path.join(getClaudeDir(), 'memory', 'current-session.json');
+    if (fs.existsSync(memoryPath)) {
+      const memory = JSON.parse(fs.readFileSync(memoryPath, 'utf8'));
+      if (memory.context && memory.context.complianceMode) {
+        return memory.context.complianceMode;
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  return null;
+}
+
+/**
+ * Check if a gate is bypassed via environment variable
+ */
+function isGateBypassed(gateId) {
+  const bypassList = process.env.CLOUDSTREAM_BYPASS_GATES;
+  if (!bypassList) return false;
+
+  return bypassList
+    .split(',')
+    .map((s) => s.trim())
+    .includes(gateId);
+}
+
+/**
+ * Log gate override for audit trail
+ */
+function logOverride(gateId, filePath, reason) {
+  const logPath = path.join(getClaudeDir(), 'sessions', 'gate-overrides.log');
+
+  try {
+    const entry = `${new Date().toISOString()} | OVERRIDE | ${gateId} | ${filePath} | ${reason || 'No reason provided'}\n`;
+
+    // Ensure directory exists
+    const dir = path.dirname(logPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.appendFileSync(logPath, entry);
+  } catch {
+    // Ignore logging errors
+  }
+}
+
+/**
+ * Check content against a gate's patterns
+ */
+function checkGatePatterns(gate, content, filePath) {
+  const violations = [];
+
+  // Skip if gate has specific file patterns and file doesn't match
+  if (gate.filePatterns) {
+    const matchesFile = gate.filePatterns.some((pattern) => {
+      const regex = new RegExp(pattern);
+      return regex.test(filePath);
+    });
+    if (!matchesFile) return violations;
+  }
+
+  // Skip if gate has exclude patterns and file matches
+  if (gate.excludePatterns) {
+    const isExcluded = gate.excludePatterns.some((pattern) => {
+      const regex = new RegExp(pattern);
+      return regex.test(filePath);
+    });
+    if (isExcluded) return violations;
+  }
+
+  // Check each pattern
+  if (gate.patterns) {
+    for (const patternStr of gate.patterns) {
+      try {
+        const regex = new RegExp(patternStr, 'gm');
+        const matches = content.match(regex);
+
+        if (matches && matches.length > 0) {
+          // If antiPatterns exist, check if they're present too
+          if (gate.antiPatterns) {
+            const hasAntiPattern = gate.antiPatterns.some((ap) => {
+              const apRegex = new RegExp(ap, 'gm');
+              return apRegex.test(content);
+            });
+            if (hasAntiPattern) continue; // Skip this violation if anti-pattern present
+          }
+
+          violations.push({
+            gateId: gate.id,
+            gateName: gate.name,
+            severity: gate.severity,
+            action: gate.action,
+            matchCount: matches.length,
+            matches: matches.slice(0, 3), // Limit to first 3 matches
+            message: gate.message,
+            remediation: gate.remediation,
+          });
+        }
+      } catch (err) {
+        log(`[QualityGate] Invalid pattern in ${gate.id}: ${patternStr}`);
+      }
+    }
+  }
+
+  // Check file size (line count)
+  if (gate.checkType === 'line_count' || gate.id === 'large_file') {
+    const lineCount = content.split('\n').length;
+    if (lineCount > (gate.threshold || 800)) {
+      violations.push({
+        gateId: gate.id,
+        gateName: gate.name,
+        severity: gate.severity,
+        action: gate.action,
+        lineCount,
+        threshold: gate.threshold || 800,
+        message: gate.message,
+        remediation: gate.remediation,
+      });
+    }
+  }
+
+  return violations;
+}
+
+/**
+ * Check for Deluge statement count
+ */
+function checkDelugeStatements(content, gate) {
+  // Simple statement count heuristic for Deluge
+  // Count semicolons and certain keywords
+  const statements = (content.match(/;/g) || []).length;
+  const ifStatements = (content.match(/\bif\b/gi) || []).length;
+  const forStatements = (content.match(/\bfor\b/gi) || []).length;
+  const whileStatements = (content.match(/\bwhile\b/gi) || []).length;
+
+  const estimatedStatements = statements + ifStatements + forStatements + whileStatements;
+
+  if (estimatedStatements > (gate.threshold || 4500)) {
+    return {
+      gateId: gate.id,
+      gateName: gate.name,
+      severity: gate.severity,
+      action: gate.action,
+      estimatedStatements,
+      threshold: gate.threshold || 4500,
+      message: `Estimated ${estimatedStatements} statements (limit: 5000). ${gate.message}`,
+      remediation: gate.remediation,
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Format violation message for output
+ */
+function formatViolation(violation) {
+  const severityEmoji = {
+    critical: '🛑',
+    high: '⚠️',
+    medium: '⚡',
+    low: 'ℹ️',
+    warning: '⚠️',
+  };
+
+  const emoji = severityEmoji[violation.severity] || '⚠️';
+  let msg = `${emoji} [${violation.severity.toUpperCase()}] ${violation.gateName}`;
+  msg += `\n   ${violation.message}`;
+
+  if (violation.matchCount) {
+    msg += `\n   Found: ${violation.matchCount} occurrence(s)`;
+  }
+
+  if (violation.lineCount) {
+    msg += `\n   Lines: ${violation.lineCount} (threshold: ${violation.threshold})`;
+  }
+
+  if (violation.remediation) {
+    msg += `\n   Fix: ${violation.remediation}`;
+  }
+
+  return msg;
+}
+
+/**
+ * Determine action based on enforcement phase
+ */
+function getEffectiveAction(violation, config) {
+  const phase = config.enforcement?.currentPhase || 'full_enforcement';
+
+  switch (phase) {
+    case 'warn_all':
+      return 'warn';
+
+    case 'block_critical':
+      return violation.severity === 'critical' ? 'block' : 'warn';
+
+    case 'full_enforcement':
+    default:
+      return violation.action;
+  }
+}
+
+/**
+ * Main hook execution
+ */
+async function main() {
+  try {
+    const input = await readStdinJson();
+    const config = loadGatesConfig();
+    const complianceMode = getComplianceMode();
+
+    // Determine what we're checking
+    const tool = input.tool;
+    const toolInput = input.tool_input || {};
+
+    let filePath = null;
+    let content = null;
+
+    // Get file path and content based on tool
+    if (tool === 'Edit' || tool === 'Write') {
+      filePath = toolInput.file_path;
+      content = toolInput.new_string || toolInput.content || '';
+
+      // For Edit, we should check the full file after edit
+      // For now, just check the new content being written
+    } else if (tool === 'Bash') {
+      const cmd = toolInput.command || '';
+
+      // Check if this is a git commit
+      if (!cmd.includes('git commit') && !cmd.includes('git push')) {
+        // Not a commit-related command, skip
+        output(JSON.stringify(input));
+        return;
+      }
+
+      // For git operations, we'd need to check staged files
+      // This is a simplified check - could be enhanced
+      log('[QualityGate] Git operation detected - pre-commit checks apply');
+    }
+
+    if (!filePath || !content) {
+      // Nothing to check
+      output(JSON.stringify(input));
+      return;
+    }
+
+    // Collect violations
+    const violations = [];
+    const blockers = [];
+    const warnings = [];
+
+    // Check each enabled gate
+    for (const [gateId, gate] of Object.entries(config.gates)) {
+      if (!gate.enabled) continue;
+
+      // Skip compliance-specific gates if not in that mode
+      if (gate.complianceMode && gate.complianceMode !== complianceMode) {
+        continue;
+      }
+
+      // Check if bypassed
+      if (isGateBypassed(gateId)) {
+        logOverride(gateId, filePath, 'ENV_BYPASS');
+        continue;
+      }
+
+      // Run gate checks
+      const gateViolations = checkGatePatterns(gate, content, filePath);
+
+      // Special check for Deluge files
+      if (gate.id === 'deluge_statement_limit' && filePath.endsWith('.ds')) {
+        const delugeViolation = checkDelugeStatements(content, gate);
+        if (delugeViolation) {
+          gateViolations.push(delugeViolation);
+        }
+      }
+
+      // Categorize violations
+      for (const violation of gateViolations) {
+        const effectiveAction = getEffectiveAction(violation, config);
+        violation.effectiveAction = effectiveAction;
+
+        if (effectiveAction === 'block') {
+          blockers.push(violation);
+        } else {
+          warnings.push(violation);
+        }
+
+        violations.push(violation);
+      }
+    }
+
+    // Output warnings
+    if (warnings.length > 0) {
+      log('[QualityGate] Warnings:');
+      for (const warning of warnings) {
+        log(formatViolation(warning));
+      }
+    }
+
+    // Handle blockers
+    if (blockers.length > 0) {
+      log('');
+      log('[QualityGate] 🛑 BLOCKED - Critical violations found:');
+      for (const blocker of blockers) {
+        log(formatViolation(blocker));
+      }
+      log('');
+      log('[QualityGate] Operation blocked. Fix violations before proceeding.');
+      log('[QualityGate] To bypass (use with caution): set CLOUDSTREAM_BYPASS_GATES=gate_id');
+
+      // Exit with error to block the operation
+      process.exit(1);
+    }
+
+    // Pass through if no blockers
+    output(JSON.stringify(input));
+  } catch (err) {
+    log(`[QualityGate] Error: ${err.message}`);
+    // On error, pass through to avoid blocking
+    output('{}');
+  }
+}
+
+// Run
+main();

package/scripts/hooks/session-end.js

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+/**
+ * Stop Hook (Session End) - Persist learnings when session ends
+ *
+ * Cross-platform (Windows, macOS, Linux)
+ *
+ * Runs when Claude session ends. Creates/updates session log file
+ * with timestamp for continuity tracking.
+ *
+ * Also integrates:
+ * - Session memory archival (corrections, preferences, patterns)
+ * - Skill effectiveness reporting
+ */
+
+const path = require('path');
+const fs = require('fs');
+const {
+  getSessionsDir,
+  getDateString,
+  getTimeString,
+  ensureDir,
+  writeFile,
+  replaceInFile,
+  log,
+} = require('../lib/utils');
+
+// Import self-healing modules (with fallback if not yet created)
+let sessionMemory = null;
+let skillEffectiveness = null;
+
+try {
+  sessionMemory = require('../lib/session-memory');
+} catch (e) {
+  // Module not yet available
+}
+
+try {
+  skillEffectiveness = require('../lib/skill-effectiveness');
+} catch (e) {
+  // Module not yet available
+}
+
+async function main() {
+  const sessionsDir = getSessionsDir();
+  const today = getDateString();
+  const sessionFile = path.join(sessionsDir, `${today}-session.tmp`);
+
+  ensureDir(sessionsDir);
+
+  const currentTime = getTimeString();
+
+  // If session file exists for today, update the end time
+  if (fs.existsSync(sessionFile)) {
+    const success = replaceInFile(
+      sessionFile,
+      /\*\*Last Updated:\*\*.*/,
+      `**Last Updated:** ${currentTime}`
+    );
+
+    if (success) {
+      log(`[SessionEnd] Updated session file: ${sessionFile}`);
+    }
+  } else {
+    // Create new session file with template
+    const template = `# Session: ${today}
+**Date:** ${today}
+**Started:** ${currentTime}
+**Last Updated:** ${currentTime}
+
+---
+
+## Current State
+
+[Session context goes here]
+
+### Completed
+- [ ]
+
+### In Progress
+- [ ]
+
+### Notes for Next Session
+-
+
+### Context to Load
+\`\`\`
+[relevant files]
+\`\`\`
+`;
+
+    writeFile(sessionFile, template);
+    log(`[SessionEnd] Created session file: ${sessionFile}`);
+  }
+
+  // === Self-Healing Integrations ===
+
+  // 1. Archive session memory (corrections, preferences, patterns)
+  if (sessionMemory) {
+    try {
+      const summary = sessionMemory.getSessionSummary();
+
+      if (summary.correctionCount > 0 || summary.effectivePatternCount > 0) {
+        log(`[SessionEnd] Session learning summary:`);
+        log(`  - Corrections recorded: ${summary.correctionCount}`);
+        log(`  - Effective patterns: ${summary.effectivePatternCount}`);
+        log(`  - Technologies used: ${summary.technologies.join(', ') || 'none'}`);
+
+        // Merge corrections to persistent knowledge
+        const mergeResult = sessionMemory.mergeCorrectionsToKnowledge();
+        if (mergeResult.success && mergeResult.merged > 0) {
+          log(`  - Merged ${mergeResult.merged} corrections to knowledge base`);
+        }
+
+        // Archive the session
+        const archiveResult = sessionMemory.archiveSession();
+        if (archiveResult.success) {
+          log(`  - Session archived for future learning`);
+        }
+      }
+    } catch (e) {
+      log(`[SessionEnd] Session memory error: ${e.message}`);
+    }
+  }
+
+  // 2. Generate skill effectiveness summary
+  if (skillEffectiveness) {
+    try {
+      const report = skillEffectiveness.getEffectivenessReport();
+
+      if (report.summary.totalApplications > 0) {
+        log(`[SessionEnd] Skill effectiveness:`);
+        log(`  - Skills applied: ${report.summary.totalApplications}`);
+        log(`  - Average effectiveness: ${Math.round(report.summary.averageEffectiveness * 100)}%`);
+
+        if (report.promotionCandidates.length > 0) {
+          log(
+            `  - Promotion candidates: ${report.promotionCandidates.map((s) => s.name).join(', ')}`
+          );
+        }
+
+        if (report.needsImprovement.length > 0) {
+          log(`  - Needs improvement: ${report.needsImprovement.map((s) => s.name).join(', ')}`);
+        }
+      }
+    } catch (e) {
+      log(`[SessionEnd] Skill effectiveness error: ${e.message}`);
+    }
+  }
+
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error('[SessionEnd] Error:', err.message);
+  process.exit(0);
+});