blockmine 1.24.0 → 1.27.0

package/.claude/hooks/test-skill-activation.ts

@@ -1,427 +0,0 @@
-#!/usr/bin/env node
-import { readFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-interface TestCase {
-    domain: string;
-    prompt: string;
-    expectedSkills: string[];
-    description: string;
-}
-
-const TEST_CASES: TestCase[] = [
-    // Development Skills
-    {
-        domain: "Backend Development",
-        prompt: "I need to create a new API endpoint for user authentication",
-        expectedSkills: ["backend-dev-guidelines"],
-        description: "API endpoint creation"
-    },
-    {
-        domain: "Backend Development",
-        prompt: "How do I implement middleware for request validation?",
-        expectedSkills: ["backend-dev-guidelines"],
-        description: "Middleware implementation"
-    },
-    {
-        domain: "Backend Development",
-        prompt: "I want to add a new route to my Express server",
-        expectedSkills: ["backend-dev-guidelines"],
-        description: "Express routing"
-    },
-    {
-        domain: "Frontend Development",
-        prompt: "Create a React component for displaying user profiles",
-        expectedSkills: ["frontend-dev-guidelines"],
-        description: "React component creation"
-    },
-    {
-        domain: "Frontend Development",
-        prompt: "I need to add a modal dialog with MUI",
-        expectedSkills: ["frontend-dev-guidelines"],
-        description: "MUI component usage"
-    },
-    {
-        domain: "Frontend Development",
-        prompt: "How do I use Suspense for data fetching?",
-        expectedSkills: ["frontend-dev-guidelines"],
-        description: "Suspense pattern"
-    },
-    {
-        domain: "Error Tracking",
-        prompt: "I need to add Sentry error tracking to my service",
-        expectedSkills: ["error-tracking", "backend-dev-guidelines"],
-        description: "Sentry integration"
-    },
-    {
-        domain: "Error Tracking",
-        prompt: "How do I capture exceptions in my controllers?",
-        expectedSkills: ["error-tracking", "backend-dev-guidelines"],
-        description: "Exception capture"
-    },
-    {
-        domain: "Route Testing",
-        prompt: "I want to test my API routes with authentication",
-        expectedSkills: ["route-tester", "backend-dev-guidelines"],
-        description: "Authenticated route testing"
-    },
-
-    // Infrastructure Skills
-    {
-        domain: "Cloud Engineering",
-        prompt: "I need to deploy my application to AWS",
-        expectedSkills: ["cloud-engineering"],
-        description: "AWS deployment"
-    },
-    {
-        domain: "Cloud Engineering",
-        prompt: "How do I set up a serverless architecture with Lambda?",
-        expectedSkills: ["cloud-engineering"],
-        description: "Serverless with Lambda"
-    },
-    {
-        domain: "Cloud Engineering",
-        prompt: "What's the best way to optimize cloud costs?",
-        expectedSkills: ["cloud-engineering", "budget-and-cost-management"],
-        description: "Cloud cost optimization"
-    },
-    {
-        domain: "Cloud Engineering",
-        prompt: "We need to deploy to Azure Government cloud for FedRAMP compliance",
-        expectedSkills: ["cloud-engineering", "devsecops"],
-        description: "Government cloud with compliance"
-    },
-    {
-        domain: "Kubernetes",
-        prompt: "I need to set up a Kubernetes cluster for production",
-        expectedSkills: ["platform-engineering"],
-        description: "Kubernetes setup"
-    },
-    {
-        domain: "Kubernetes",
-        prompt: "How do I configure Helm charts for my application?",
-        expectedSkills: ["platform-engineering"],
-        description: "Helm configuration"
-    },
-    {
-        domain: "Security",
-        prompt: "I need to implement security scanning in my CI/CD pipeline",
-        expectedSkills: ["devsecops"],
-        description: "Security scanning setup"
-    },
-    {
-        domain: "Security",
-        prompt: "How do I secure container images?",
-        expectedSkills: ["devsecops"],
-        description: "Container security"
-    },
-    {
-        domain: "Security",
-        prompt: "We need to pass a CMMC audit",
-        expectedSkills: ["devsecops"],
-        description: "CMMC compliance"
-    },
-    {
-        domain: "SRE",
-        prompt: "I need to define SLOs for our service",
-        expectedSkills: ["sre"],
-        description: "SLO definition"
-    },
-    {
-        domain: "SRE",
-        prompt: "How do I set up monitoring and alerting?",
-        expectedSkills: ["sre", "observability-engineering"],
-        description: "Monitoring setup"
-    },
-    {
-        domain: "SRE",
-        prompt: "We're having an outage, how do I debug?",
-        expectedSkills: ["sre"],
-        description: "Incident response"
-    },
-    {
-        domain: "Architecture",
-        prompt: "I need to design a multi-region architecture",
-        expectedSkills: ["infrastructure-architecture"],
-        description: "Multi-region design"
-    },
-    {
-        domain: "Architecture",
-        prompt: "How do I write an ADR for our system?",
-        expectedSkills: ["infrastructure-architecture"],
-        description: "ADR creation"
-    },
-    {
-        domain: "Architecture",
-        prompt: "We need disaster recovery planning",
-        expectedSkills: ["infrastructure-architecture"],
-        description: "DR planning"
-    },
-    {
-        domain: "Database",
-        prompt: "My PostgreSQL queries are slow",
-        expectedSkills: ["database-engineering"],
-        description: "Query optimization"
-    },
-    {
-        domain: "Database",
-        prompt: "How do I set up database replication?",
-        expectedSkills: ["database-engineering"],
-        description: "Database replication"
-    },
-    {
-        domain: "Observability",
-        prompt: "I need to implement distributed tracing",
-        expectedSkills: ["observability-engineering"],
-        description: "Distributed tracing"
-    },
-    {
-        domain: "Observability",
-        prompt: "How do I set up OpenTelemetry?",
-        expectedSkills: ["observability-engineering"],
-        description: "OpenTelemetry setup"
-    },
-    {
-        domain: "API Design",
-        prompt: "I'm designing a GraphQL API",
-        expectedSkills: ["api-engineering"],
-        description: "GraphQL design"
-    },
-    {
-        domain: "API Design",
-        prompt: "How do I implement rate limiting for my API?",
-        expectedSkills: ["api-engineering", "backend-dev-guidelines"],
-        description: "Rate limiting"
-    },
-
-    // Management Skills
-    {
-        domain: "Engineering Management",
-        prompt: "I need to hire a senior engineer",
-        expectedSkills: ["engineering-management"],
-        description: "Hiring process"
-    },
-    {
-        domain: "Engineering Management",
-        prompt: "How do I structure my team for better productivity?",
-        expectedSkills: ["engineering-management"],
-        description: "Team structure"
-    },
-    {
-        domain: "Engineering Management",
-        prompt: "I need to prepare for 1-on-1s with my reports",
-        expectedSkills: ["engineering-management"],
-        description: "1-on-1 preparation"
-    },
-    {
-        domain: "Technical Leadership",
-        prompt: "My team wants to rewrite everything in Rust",
-        expectedSkills: ["technical-leadership"],
-        description: "Technology decision"
-    },
-    {
-        domain: "Technical Leadership",
-        prompt: "Should we adopt microservices architecture?",
-        expectedSkills: ["technical-leadership", "infrastructure-architecture"],
-        description: "Architecture decision"
-    },
-    {
-        domain: "Technical Leadership",
-        prompt: "How do I evaluate this technical proposal?",
-        expectedSkills: ["technical-leadership"],
-        description: "Proposal evaluation"
-    },
-    {
-        domain: "Infrastructure Strategy",
-        prompt: "Should we build or buy our authentication system?",
-        expectedSkills: ["infrastructure-strategy"],
-        description: "Build vs buy decision"
-    },
-    {
-        domain: "Infrastructure Strategy",
-        prompt: "I need to create a 3-year infrastructure roadmap",
-        expectedSkills: ["infrastructure-strategy"],
-        description: "Multi-year roadmap"
-    },
-    {
-        domain: "Budget Management",
-        prompt: "Our AWS bill is too high, how do I reduce costs?",
-        expectedSkills: ["budget-and-cost-management", "cloud-engineering"],
-        description: "Cost reduction"
-    },
-    {
-        domain: "Budget Management",
-        prompt: "I need to prepare an infrastructure budget request",
-        expectedSkills: ["budget-and-cost-management"],
-        description: "Budget planning"
-    },
-    {
-        domain: "Operations Management",
-        prompt: "How do I set up an on-call rotation?",
-        expectedSkills: ["engineering-operations-management"],
-        description: "On-call setup"
-    },
-    {
-        domain: "Operations Management",
-        prompt: "We need to write a postmortem for the outage",
-        expectedSkills: ["engineering-operations-management", "sre"],
-        description: "Postmortem process"
-    },
-
-    // Skill Development
-    {
-        domain: "Skill Development",
-        prompt: "How do I create a new Claude Code skill?",
-        expectedSkills: ["skill-developer"],
-        description: "Skill creation"
-    },
-    {
-        domain: "Skill Development",
-        prompt: "I need to modify skill-rules.json",
-        expectedSkills: ["skill-developer"],
-        description: "Skill rules modification"
-    },
-    {
-        domain: "Skill Development",
-        prompt: "How do skill triggers work?",
-        expectedSkills: ["skill-developer"],
-        description: "Skill triggers understanding"
-    },
-
-    // Mixed/Complex Scenarios
-    {
-        domain: "Full Stack Project",
-        prompt: "I'm building a web app with React frontend and Express backend",
-        expectedSkills: ["frontend-dev-guidelines", "backend-dev-guidelines"],
-        description: "Full stack development"
-    },
-    {
-        domain: "Cloud Migration",
-        prompt: "We need to migrate our monolith to microservices on AWS",
-        expectedSkills: ["cloud-engineering", "infrastructure-architecture"],
-        description: "Cloud migration planning"
-    },
-    {
-        domain: "Secure Production",
-        prompt: "I need to deploy to production with security scanning and monitoring",
-        expectedSkills: ["devsecops", "platform-engineering", "observability-engineering"],
-        description: "Secure production deployment"
-    },
-    {
-        domain: "Compliance & Cloud",
-        prompt: "Deploy HIPAA-compliant healthcare app to AWS",
-        expectedSkills: ["cloud-engineering", "devsecops"],
-        description: "Compliance cloud deployment"
-    },
-];
-
-async function testHook(prompt: string): Promise<string> {
-    const projectDir = join(__dirname, '..', '..');
-    const hookScript = join(__dirname, 'skill-activation-prompt.sh');
-    const input = JSON.stringify({
-        session_id: "test-session",
-        prompt: prompt,
-        cwd: process.cwd(),
-        permission_mode: "acceptEdits",
-        transcript_path: "/tmp/test"
-    });
-
-    try {
-        const { stdout } = await execAsync(`export CLAUDE_PROJECT_DIR="${projectDir}" && echo '${input.replace(/'/g, "'\\''")}' | ${hookScript}`);
-        return stdout;
-    } catch (error: any) {
-        return error.stdout || '';
-    }
-}
-
-function extractSkillsFromOutput(output: string): string[] {
-    const skills: string[] = [];
-    const lines = output.split('\n');
-
-    for (const line of lines) {
-        if (line.trim().startsWith('→')) {
-            const match = line.match(/→\s*([a-z-]+)/);
-            if (match) {
-                skills.push(match[1]);
-            }
-        }
-    }
-
-    return skills;
-}
-
-async function runTests() {
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    console.log('🧪 COMPREHENSIVE SKILL ACTIVATION TESTING');
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-
-    let passed = 0;
-    let failed = 0;
-    let warnings = 0;
-
-    for (const testCase of TEST_CASES) {
-        console.log(`\n📝 Testing: ${testCase.domain} - ${testCase.description}`);
-        console.log(`   Prompt: "${testCase.prompt}"`);
-        console.log(`   Expected skills: ${testCase.expectedSkills.join(', ')}`);
-
-        const output = await testHook(testCase.prompt);
-        const detectedSkills = extractSkillsFromOutput(output);
-
-        console.log(`   Detected skills: ${detectedSkills.length > 0 ? detectedSkills.join(', ') : 'none'}`);
-
-        // Check if at least one expected skill was detected
-        const hasExpectedSkill = testCase.expectedSkills.some(expected =>
-            detectedSkills.includes(expected)
-        );
-
-        if (hasExpectedSkill) {
-            console.log(`   ✅ PASS - Detected expected skill(s)`);
-            passed++;
-
-            // Warn if extra skills detected
-            const extraSkills = detectedSkills.filter(s => !testCase.expectedSkills.includes(s));
-            if (extraSkills.length > 0) {
-                console.log(`   ⚠️  Additional skills detected: ${extraSkills.join(', ')}`);
-                warnings++;
-            }
-        } else if (detectedSkills.length === 0) {
-            console.log(`   ❌ FAIL - No skills detected`);
-            failed++;
-        } else {
-            console.log(`   ⚠️  PARTIAL - Detected different skills: ${detectedSkills.join(', ')}`);
-            warnings++;
-        }
-    }
-
-    console.log('\n');
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    console.log('📊 TEST RESULTS');
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
-    console.log(`   Total Tests:     ${TEST_CASES.length}`);
-    console.log(`   ✅ Passed:        ${passed}`);
-    console.log(`   ❌ Failed:        ${failed}`);
-    console.log(`   ⚠️  Warnings:      ${warnings}`);
-    console.log(`   Success Rate:    ${((passed / TEST_CASES.length) * 100).toFixed(1)}%`);
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
-
-    if (failed > 0) {
-        console.log('⚠️  Some tests failed. Review the skill-rules.json patterns.');
-        process.exit(1);
-    } else {
-        console.log('✅ All tests passed! Skill activation system is working correctly.');
-        process.exit(0);
-    }
-}
-
-runTests().catch(err => {
-    console.error('Error running tests:', err);
-    process.exit(1);
-});

package/.claude/hooks/trigger-build-resolver.sh

@@ -1,79 +0,0 @@
-#!/bin/bash
-echo "Hook triggered at $(date)" >> /tmp/claude-hook-debug.log
-echo "Args: $@" >> /tmp/claude-hook-debug.log
-echo "Stdin:" >> /tmp/claude-hook-debug.log
-cat >> /tmp/claude-hook-debug.log
-
-# Add detailed debugging
-echo "=== DEBUG SECTION ===" >> /tmp/claude-hook-debug.log
-echo "CLAUDE_PROJECT_DIR: $CLAUDE_PROJECT_DIR" >> /tmp/claude-hook-debug.log
-echo "Current working directory: $(pwd)" >> /tmp/claude-hook-debug.log
-
-# Define the service directories to check
-services_dirs=("email" "exports" "form" "frontend" "projects" "uploads" "users" "utilities" "events" "database")
-services_with_changes=()
-
-# Check each service directory for git changes
-for service in "${services_dirs[@]}"; do
-    service_path="$CLAUDE_PROJECT_DIR/$service"
-    echo "Checking service: $service at $service_path" >> /tmp/claude-hook-debug.log
-    
-    # Check if directory exists and is a git repo
-    if [ -d "$service_path" ] && [ -d "$service_path/.git" ]; then
-        echo "  -> Is a git repository" >> /tmp/claude-hook-debug.log
-        
-        # Check for changes in this specific repo
-        cd "$service_path"
-        git_status=$(git status --porcelain 2>/dev/null)
-        
-        if [ -n "$git_status" ]; then
-            echo "  -> Has changes:" >> /tmp/claude-hook-debug.log
-            echo "$git_status" | sed 's/^/    /' >> /tmp/claude-hook-debug.log
-            services_with_changes+=("$service")
-        else
-            echo "  -> No changes" >> /tmp/claude-hook-debug.log
-        fi
-    else
-        echo "  -> Not a git repository or doesn't exist" >> /tmp/claude-hook-debug.log
-    fi
-done
-
-# Return to original directory
-cd "$CLAUDE_PROJECT_DIR"
-
-echo "Services with changes: ${services_with_changes[@]}" >> /tmp/claude-hook-debug.log
-
-if [[ ${#services_with_changes[@]} -gt 0 ]]; then
-    services_list=$(IFS=', '; echo "${services_with_changes[*]}")
-    echo "Changes detected in: $services_list — triggering build-error-resolver..." >> /tmp/claude-hook-debug.log
-    echo "Changes detected in: $services_list — triggering build-error-resolver..." >&2
-
-    # Use the correct Claude CLI syntax - try different options
-    echo "Attempting to run claude with sub-agent..." >> /tmp/claude-hook-debug.log
-    
-    # Try different possible syntaxes for sub-agents
-    if command -v claude >/dev/null 2>&1; then
-        # Option 1: Try direct agent invocation
-        claude --agent build-error-resolver <<EOF 2>> /tmp/claude-hook-debug.log
-Build and fix errors in these specific services only: ${services_list}
-
-Focus on these services in the monorepo structure. Each service has its own build process.
-EOF
-        
-        # If that fails, try alternative syntax
-        if [ $? -ne 0 ]; then
-            echo "First attempt failed, trying alternative syntax..." >> /tmp/claude-hook-debug.log
-            claude chat "Use the build-error-resolver agent to build and fix errors in: ${services_list}" 2>> /tmp/claude-hook-debug.log
-        fi
-    else
-        echo "Claude CLI not found in PATH" >> /tmp/claude-hook-debug.log
-    fi
-    
-    echo "Claude command completed with exit code: $?" >> /tmp/claude-hook-debug.log
-else
-    echo "No services with changes detected — skipping build-error-resolver." >> /tmp/claude-hook-debug.log
-    echo "No services with changes detected — skipping build-error-resolver." >&2
-fi
-
-echo "=== END DEBUG SECTION ===" >> /tmp/claude-hook-debug.log
-exit 0

package/.claude/hooks/tsc-check.sh

@@ -1,173 +0,0 @@
-#!/bin/bash
-
-# TSC Hook with Visible Output
-# Uses stderr for visibility in Claude Code main interface
-
-export CLAUDE_PROJECT_DIR="${CLAUDE_PROJECT_DIR:-$HOME/project}"
-HOOK_INPUT=$(cat)
-SESSION_ID="${session_id:-default}"
-CACHE_DIR="$HOME/.claude/tsc-cache/$SESSION_ID"
-
-# Create cache directory
-mkdir -p "$CACHE_DIR"
-
-# Extract tool name and input
-TOOL_NAME=$(echo "$HOOK_INPUT" | jq -r '.tool_name // ""')
-TOOL_INPUT=$(echo "$HOOK_INPUT" | jq -r '.tool_input // {}')
-
-# Function to get repo for a file
-get_repo_for_file() {
-    local file_path="$1"
-    local relative_path="${file_path#$CLAUDE_PROJECT_DIR/}"
-    
-    if [[ "$relative_path" =~ ^([^/]+)/ ]]; then
-        local repo="${BASH_REMATCH[1]}"
-        case "$repo" in
-            email|exports|form|frontend|projects|uploads|users|utilities|events|database)
-                echo "$repo"
-                return 0
-                ;;
-        esac
-    fi
-    echo ""
-    return 1
-}
-
-# Function to detect the correct TSC command for a repo
-get_tsc_command() {
-    local repo_path="$1"
-    cd "$repo_path" 2>/dev/null || return 1
-    
-    if [ -f "tsconfig.app.json" ]; then
-        echo "npx tsc --project tsconfig.app.json --noEmit"
-    elif [ -f "tsconfig.build.json" ]; then
-        echo "npx tsc --project tsconfig.build.json --noEmit"
-    elif [ -f "tsconfig.json" ]; then
-        if grep -q '"references"' tsconfig.json 2>/dev/null; then
-            if [ -f "tsconfig.app.json" ]; then
-                echo "npx tsc --project tsconfig.app.json --noEmit"
-            elif [ -f "tsconfig.src.json" ]; then
-                echo "npx tsc --project tsconfig.src.json --noEmit"
-            else
-                echo "npx tsc --build --noEmit"
-            fi
-        else
-            echo "npx tsc --noEmit"
-        fi
-    else
-        echo "npx tsc --noEmit"
-    fi
-}
-
-# Function to run TSC check
-run_tsc_check() {
-    local repo="$1"
-    local repo_path="$CLAUDE_PROJECT_DIR/$repo"
-    local cache_file="$CACHE_DIR/$repo-tsc-cmd.cache"
-    
-    cd "$repo_path" 2>/dev/null || return 1
-    
-    # Get or cache the TSC command for this repo
-    local tsc_cmd
-    if [ -f "$cache_file" ] && [ -z "$FORCE_DETECT" ]; then
-        tsc_cmd=$(cat "$cache_file")
-    else
-        tsc_cmd=$(get_tsc_command "$repo_path")
-        echo "$tsc_cmd" > "$cache_file"
-    fi
-    
-    eval "$tsc_cmd" 2>&1
-}
-
-# Only process file modification tools
-case "$TOOL_NAME" in
-    Write|Edit|MultiEdit)
-        # Extract file paths
-        if [ "$TOOL_NAME" = "MultiEdit" ]; then
-            FILE_PATHS=$(echo "$TOOL_INPUT" | jq -r '.edits[].file_path // empty')
-        else
-            FILE_PATHS=$(echo "$TOOL_INPUT" | jq -r '.file_path // empty')
-        fi
-        
-        # Collect repos that need checking (only for TS/JS files)
-        REPOS_TO_CHECK=$(echo "$FILE_PATHS" | grep -E '\.(ts|tsx|js|jsx)$' | while read -r file_path; do
-            if [ -n "$file_path" ]; then
-                repo=$(get_repo_for_file "$file_path")
-                [ -n "$repo" ] && echo "$repo"
-            fi
-        done | sort -u | tr '\n' ' ')
-        
-        # Trim whitespace
-        REPOS_TO_CHECK=$(echo "$REPOS_TO_CHECK" | xargs)
-        
-        if [ -n "$REPOS_TO_CHECK" ]; then
-            ERROR_COUNT=0
-            ERROR_OUTPUT=""
-            FAILED_REPOS=""
-            
-            # Output to stderr for visibility
-            echo "⚡ TypeScript check on: $REPOS_TO_CHECK" >&2
-            
-            for repo in $REPOS_TO_CHECK; do
-                echo -n "  Checking $repo... " >&2
-                
-                # Run the check and capture output
-                CHECK_OUTPUT=$(run_tsc_check "$repo" 2>&1)
-                CHECK_EXIT_CODE=$?
-                
-                # Check for TypeScript errors in output
-                if [ $CHECK_EXIT_CODE -ne 0 ] || echo "$CHECK_OUTPUT" | grep -q "error TS"; then
-                    echo "❌ Errors found" >&2
-                    ERROR_COUNT=$((ERROR_COUNT + 1))
-                    FAILED_REPOS="$FAILED_REPOS $repo"
-                    ERROR_OUTPUT="${ERROR_OUTPUT}
-
-=== Errors in $repo ===
-$CHECK_OUTPUT"
-                else
-                    echo "✅ OK" >&2
-                fi
-            done
-            
-            # If errors were found, show them and save for agent
-            if [ $ERROR_COUNT -gt 0 ]; then
-                # Save error information for the agent
-                echo "$ERROR_OUTPUT" > "$CACHE_DIR/last-errors.txt"
-                echo "$FAILED_REPOS" > "$CACHE_DIR/affected-repos.txt"
-                
-                # Save the TSC commands used for each repo
-                echo "# TSC Commands by Repo" > "$CACHE_DIR/tsc-commands.txt"
-                for repo in $FAILED_REPOS; do
-                    cmd=$(cat "$CACHE_DIR/$repo-tsc-cmd.cache" 2>/dev/null || echo "npx tsc --noEmit")
-                    echo "$repo: $cmd" >> "$CACHE_DIR/tsc-commands.txt"
-                done
-                
-                # Output to stderr for visibility
-                {
-                    echo ""
-                    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-                    echo "🚨 TypeScript errors found in $ERROR_COUNT repo(s): $FAILED_REPOS"
-                    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-                    echo ""
-                    echo "👉 IMPORTANT: Use the auto-error-resolver agent to fix the errors"
-                    echo ""
-                    echo "WE DO NOT LEAVE A MESS BEHIND"
-                    echo "Error Preview:"
-                    echo "$ERROR_OUTPUT" | grep "error TS" | head -10
-                    echo ""
-                    if [ $(echo "$ERROR_OUTPUT" | grep -c "error TS") -gt 10 ]; then
-                        echo "... and $(($(echo "$ERROR_OUTPUT" | grep -c "error TS") - 10)) more errors"
-                    fi
-                } >&2
-                
-                # Exit with code 1 to make stderr visible
-                exit 1
-            fi
-        fi
-        ;;
-esac
-
-# Cleanup old cache directories (older than 7 days)
-find "$HOME/.claude/tsc-cache" -maxdepth 1 -type d -mtime +7 -exec rm -rf {} \; 2>/dev/null || true
-
-exit 0