blockmine 1.21.0 → 1.23.0

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

@@ -0,0 +1,427 @@
+#!/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

@@ -0,0 +1,79 @@
+#!/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

@@ -0,0 +1,173 @@
+#!/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