🎉 Initial commit: Living-LLM Revolutionary AI Architecture

🧬 Features:
- Custom 1B parameter transformer built from scratch
- Genetic evolution system for architecture optimization
- Continuous web learning with quality filtering
- Uncensored knowledge distillation from teacher models
- Real-time monitoring dashboard with WebSocket updates
- Plagiarism-free content generation
- Production-ready distributed training system

🚀 This is the beginning of truly living AI that evolves and adapts!

🤖 Generated with Claude Code
Co-Authored-By: Claude <noreply@anthropic.com>

Author: Living-LLM Bot

.DS_Store

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""
+Check for evolution changes in Living-LLM system and determine if auto-commit is needed.
+"""
+
+import os
+import json
+import yaml
+import hashlib
+from pathlib import Path
+from datetime import datetime
+import git
+import sys
+
+def calculate_file_hash(file_path):
+    """Calculate SHA256 hash of a file."""
+    if not os.path.exists(file_path):
+        return None
+    
+    with open(file_path, 'rb') as f:
+        return hashlib.sha256(f.read()).hexdigest()
+
+def load_evolution_state():
+    """Load current evolution state from checkpoints."""
+    evolution_dir = Path("evolution_checkpoints")
+    if not evolution_dir.exists():
+        return None
+    
+    # Find latest evolution checkpoint
+    checkpoints = list(evolution_dir.glob("evolution_gen_*.json"))
+    if not checkpoints:
+        return None
+    
+    latest_checkpoint = max(checkpoints, key=os.path.getctime)
+    
+    try:
+        with open(latest_checkpoint, 'r') as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Error loading evolution state: {e}")
+        return None
+
+def load_previous_state():
+    """Load previous evolution state from git metadata."""
+    state_file = Path(".github/evolution_state.json")
+    if not state_file.exists():
+        return {}
+    
+    try:
+        with open(state_file, 'r') as f:
+            return json.load(f)
+    except:
+        return {}
+
+def save_current_state(state):
+    """Save current evolution state for future comparison."""
+    state_file = Path(".github/evolution_state.json")
+    state_file.parent.mkdir(parents=True, exist_ok=True)
+    
+    with open(state_file, 'w') as f:
+        json.dump(state, f, indent=2, default=str)
+
+def check_model_changes():
+    """Check if model architecture files have changed."""
+    model_files = [
+        "src/core/model/transformer.py",
+        "src/core/attention/multi_head_attention.py",
+        "src/core/layers/",
+        "configs/model/"
+    ]
+    
+    changes = {}
+    for file_path in model_files:
+        if os.path.exists(file_path):
+            if os.path.isdir(file_path):
+                # Check all files in directory
+                for root, dirs, files in os.walk(file_path):
+                    for file in files:
+                        if file.endswith('.py') or file.endswith('.yaml'):
+                            full_path = os.path.join(root, file)
+                            changes[full_path] = calculate_file_hash(full_path)
+            else:
+                changes[file_path] = calculate_file_hash(file_path)
+    
+    return changes
+
+def check_training_progress():
+    """Check training progress and metrics."""
+    logs_dir = Path("logs/training")
+    if not logs_dir.exists():
+        return {}
+    
+    # Get latest training log
+    log_files = list(logs_dir.glob("*.log"))
+    if not log_files:
+        return {}
+    
+    latest_log = max(log_files, key=os.path.getctime)
+    
+    # Extract key metrics from log
+    metrics = {
+        'latest_loss': None,
+        'best_loss': None,
+        'total_steps': 0,
+        'last_update': datetime.now().isoformat()
+    }
+    
+    try:
+        with open(latest_log, 'r') as f:
+            lines = f.readlines()
+            for line in reversed(lines[-100:]):  # Check last 100 lines
+                if 'loss:' in line.lower():
+                    # Extract loss value
+                    import re
+                    loss_match = re.search(r'loss:\s*([0-9.]+)', line.lower())
+                    if loss_match and metrics['latest_loss'] is None:
+                        metrics['latest_loss'] = float(loss_match.group(1))
+                
+                if 'step' in line.lower():
+                    step_match = re.search(r'step[:\s]+(\d+)', line.lower())
+                    if step_match:
+                        metrics['total_steps'] = max(metrics['total_steps'], int(step_match.group(1)))
+    except Exception as e:
+        print(f"Error parsing training logs: {e}")
+    
+    return metrics
+
+def determine_change_type(current_state, previous_state):
+    """Determine the type and significance of changes."""
+    changes = {
+        'has_changes': False,
+        'major_evolution': False,
+        'architecture_changed': False,
+        'performance_improved': False,
+        'new_generation': False,
+        'change_summary': []
+    }
+    
+    # Check evolution progress
+    if 'evolution' in current_state and 'evolution' in previous_state:
+        current_gen = current_state['evolution'].get('generation', 0)
+        previous_gen = previous_state['evolution'].get('generation', 0)
+        
+        if current_gen > previous_gen:
+            changes['has_changes'] = True
+            changes['new_generation'] = True
+            changes['change_summary'].append(f"Evolution advanced to generation {current_gen}")
+            
+            # Check if fitness improved significantly
+            current_fitness = current_state['evolution'].get('best_fitness', 0)
+            previous_fitness = previous_state['evolution'].get('best_fitness', 0)
+            
+            if current_fitness > previous_fitness * 1.1:  # 10% improvement
+                changes['major_evolution'] = True
+                changes['change_summary'].append(f"Major fitness improvement: {previous_fitness:.4f} → {current_fitness:.4f}")
+    
+    # Check model architecture changes
+    current_model = current_state.get('model_files', {})
+    previous_model = previous_state.get('model_files', {})
+    
+    architecture_changes = []
+    for file_path, current_hash in current_model.items():
+        previous_hash = previous_model.get(file_path)
+        if previous_hash != current_hash:
+            changes['has_changes'] = True
+            changes['architecture_changed'] = True
+            architecture_changes.append(file_path)
+    
+    if architecture_changes:
+        changes['change_summary'].append(f"Architecture files changed: {', '.join(architecture_changes)}")
+    
+    # Check training performance
+    current_training = current_state.get('training', {})
+    previous_training = previous_state.get('training', {})
+    
+    current_loss = current_training.get('latest_loss')
+    previous_loss = previous_training.get('latest_loss')
+    
+    if current_loss and previous_loss and current_loss < previous_loss * 0.95:  # 5% improvement
+        changes['has_changes'] = True
+        changes['performance_improved'] = True
+        changes['change_summary'].append(f"Training loss improved: {previous_loss:.4f} → {current_loss:.4f}")
+    
+    return changes
+
+def main():
+    """Main function to check for evolution changes."""
+    print("🔍 Checking for Living-LLM evolution changes...")
+    
+    # Load current system state
+    current_state = {
+        'timestamp': datetime.now().isoformat(),
+        'evolution': load_evolution_state(),
+        'model_files': check_model_changes(),
+        'training': check_training_progress()
+    }
+    
+    # Load previous state
+    previous_state = load_previous_state()
+    
+    # Determine changes
+    changes = determine_change_type(current_state, previous_state)
+    
+    # Output results for GitHub Actions
+    print(f"::set-output name=has_changes::{str(changes['has_changes']).lower()}")
+    print(f"::set-output name=major_evolution::{str(changes['major_evolution']).lower()}")
+    print(f"::set-output name=architecture_changed::{str(changes['architecture_changed']).lower()}")
+    print(f"::set-output name=performance_improved::{str(changes['performance_improved']).lower()}")
+    
+    if changes['has_changes']:
+        # Generate evolution ID
+        evolution_id = f"{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        print(f"::set-output name=evolution_id::{evolution_id}")
+        
+        # Save current state for next run
+        save_current_state(current_state)
+        
+        print("✨ Evolution changes detected!")
+        for change in changes['change_summary']:
+            print(f"  • {change}")
+    else:
+        print("🔄 No significant changes detected.")
+    
+    # Save state for next comparison
+    save_current_state(current_state)
+    
+    return 0 if not changes['has_changes'] else 1
+
+if __name__ == "__main__":
+    sys.exit(main())