update

DEPLOYMENT.md

@@ -0,0 +1,585 @@
+# HuggingFace Spaces 自动修复系统部署指南
+
+## 📋 部署概览
+
+本系统支持多种部署方式：
+- **Docker Compose 部署**（推荐）
+- **本地 Python 部署**
+- **Kubernetes 部署**
+- **云服务部署**
+
+## 🐳 Docker Compose 部署（推荐）
+
+### 1. 环境准备
+
+```bash
+# 克隆项目
+git clone <repository-url>
+cd hf-repair-system
+
+# 创建环境变量文件
+cp .env.example .env
+
+# 编辑环境变量
+nano .env
+```
+
+### 2. 环境变量配置
+
+```bash
+# .env 文件内容
+HF_TOKEN=your_huggingface_token_here
+WEBHOOK_URL=your_webhook_url_here
+REDIS_PASSWORD=your_redis_password_here
+POSTGRES_PASSWORD=your_postgres_password_here
+GRAFANA_PASSWORD=your_grafana_password_here
+
+# 可选配置
+LOG_LEVEL=INFO
+CHECK_INTERVAL=60
+MAX_CONCURRENT_SPACES=10
+```
+
+### 3. 启动系统
+
+```bash
+# 构建并启动所有服务
+docker-compose up -d
+
+# 查看服务状态
+docker-compose ps
+
+# 查看日志
+docker-compose logs -f hf-repair-system
+```
+
+### 4. 验证部署
+
+```bash
+# 检查健康状态
+curl http://localhost:8080/health
+
+# 访问 Web 界面
+open http://localhost:3000
+
+# 访问 Grafana 监控
+open http://localhost:3001
+```
+
+## 🐧 本地 Python 部署
+
+### 1. 环境准备
+
+```bash
+# Python 3.11+
+python3.11 -m venv venv
+source venv/bin/activate  # Linux/Mac
+# 或
+venv\Scripts\activate  # Windows
+
+# 安装依赖
+pip install -r requirements.txt
+```
+
+### 2. 配置文件
+
+```bash
+# 复制配置模板
+cp config_template.json config.json
+
+# 编辑配置
+nano config.json
+```
+
+### 3. 数据库初始化
+
+```bash
+# 创建数据目录
+mkdir -p data logs backups
+
+# 初始化数据库
+python -m repair_system.db.init
+```
+
+### 4. 启动服务
+
+```bash
+# 启动主服务
+python main.py
+
+# 或使用 start 脚本
+./start.sh
+```
+
+## ☸️ Kubernetes 部署
+
+### 1. 准备 Kubernetes 配置
+
+```yaml
+# k8s/namespace.yaml
+apiVersion: v1
+kind: Namespace
+metadata:
+  name: hf-repair-system
+
+---
+# k8s/configmap.yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: hf-repair-config
+  namespace: hf-repair-system
+data:
+  config.json: |
+    {
+      "system": {
+        "name": "HuggingFace Spaces 自动修复系统",
+        "log_level": "INFO"
+      },
+      "huggingface": {
+        "api_token": "${HF_TOKEN}",
+        "base_url": "https://huggingface.co/api"
+      }
+    }
+
+---
+# k8s/secret.yaml
+apiVersion: v1
+kind: Secret
+metadata:
+  name: hf-repair-secrets
+  namespace: hf-repair-system
+type: Opaque
+data:
+  hf-token: <base64-encoded-token>
+  webhook-url: <base64-encoded-webhook-url>
+
+---
+# k8s/deployment.yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: hf-repair-system
+  namespace: hf-repair-system
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: hf-repair-system
+  template:
+    metadata:
+      labels:
+        app: hf-repair-system
+    spec:
+      containers:
+      - name: repair-system
+        image: hf-repair-system:latest
+        ports:
+        - containerPort: 8080
+        env:
+        - name: HF_TOKEN
+          valueFrom:
+            secretKeyRef:
+              name: hf-repair-secrets
+              key: hf-token
+        volumeMounts:
+        - name: config
+          mountPath: /app/config
+        - name: data
+          mountPath: /app/data
+        resources:
+          requests:
+            memory: "512Mi"
+            cpu: "250m"
+          limits:
+            memory: "1Gi"
+            cpu: "500m"
+      volumes:
+      - name: config
+        configMap:
+          name: hf-repair-config
+      - name: data
+        persistentVolumeClaim:
+          claimName: hf-repair-data
+
+---
+# k8s/service.yaml
+apiVersion: v1
+kind: Service
+metadata:
+  name: hf-repair-service
+  namespace: hf-repair-system
+spec:
+  selector:
+    app: hf-repair-system
+  ports:
+  - port: 80
+    targetPort: 8080
+  type: ClusterIP
+
+---
+# k8s/ingress.yaml
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: hf-repair-ingress
+  namespace: hf-repair-system
+  annotations:
+    nginx.ingress.kubernetes.io/rewrite-target: /
+spec:
+  rules:
+  - host: hf-repair.yourdomain.com
+    http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: hf-repair-service
+            port:
+              number: 80
+```
+
+### 2. 部署到 Kubernetes
+
+```bash
+# 创建命名空间和配置
+kubectl apply -f k8s/namespace.yaml
+kubectl apply -f k8s/configmap.yaml
+kubectl apply -f k8s/secret.yaml
+
+# 部署应用
+kubectl apply -f k8s/deployment.yaml
+kubectl apply -f k8s/service.yaml
+kubectl apply -f k8s/ingress.yaml
+
+# 检查部署状态
+kubectl get pods -n hf-repair-system
+kubectl logs -f deployment/hf-repair-system -n hf-repair-system
+```
+
+## 🌩️ 云服务部署
+
+### AWS 部署
+
+```bash
+# 使用 AWS CLI
+aws ecs create-cluster --cluster-name hf-repair-cluster
+aws ecs register-task-definition --cli-input-json file://task-definition.json
+aws ecs create-service --cluster hf-repair-cluster --service-name hf-repair-service --task-definition hf-repair-task
+
+# 设置 CloudWatch 日志
+aws logs create-log-group --log-group-name /ecs/hf-repair-system
+```
+
+### Google Cloud 部署
+
+```bash
+# 使用 gcloud
+gcloud run deploy hf-repair-system \
+  --image gcr.io/your-project/hf-repair-system:latest \
+  --platform managed \
+  --region us-central1 \
+  --allow-unauthenticated \
+  --set-env-vars HF_TOKEN=$HF_TOKEN
+```
+
+### Azure 部署
+
+```bash
+# 使用 Azure CLI
+az container create \
+  --resource-group hf-repair-rg \
+  --name hf-repair-system \
+  --image your-registry/hf-repair-system:latest \
+  --environment-variables HF_TOKEN=$HF_TOKEN \
+  --ports 8080
+```
+
+## 🔧 配置管理
+
+### 生产环境配置
+
+```json
+{
+  "system": {
+    "log_level": "WARNING",
+    "debug": false
+  },
+  "monitoring": {
+    "check_interval": 30,
+    "max_concurrent_spaces": 20
+  },
+  "performance": {
+    "max_concurrent_repairs": 10,
+    "worker_threads": 8
+  },
+  "database": {
+    "type": "postgresql",
+    "host": "postgres",
+    "port": 5432,
+    "database": "hf_repair",
+    "username": "hf_repair",
+    "password": "${POSTGRES_PASSWORD}"
+  }
+}
+```
+
+### 开发环境配置
+
+```json
+{
+  "system": {
+    "log_level": "DEBUG",
+    "debug": true
+  },
+  "monitoring": {
+    "check_interval": 60,
+    "max_concurrent_spaces": 3
+  },
+  "file_operations": {
+    "git": {
+      "auto_commit": false,
+      "push_immediately": false
+    }
+  }
+}
+```
+
+## 📊 监控和日志
+
+### Prometheus 配置
+
+```yaml
+# monitoring/prometheus.yml
+global:
+  scrape_interval: 15s
+
+scrape_configs:
+  - job_name: 'hf-repair-system'
+    static_configs:
+      - targets: ['hf-repair-system:8080']
+    metrics_path: /metrics
+    scrape_interval: 30s
+```
+
+### Grafana 仪表板
+
+1. 访问 http://localhost:3001
+2. 导入预配置的仪表板
+3. 设置数据源为 Prometheus
+
+## 🔒 安全配置
+
+### 网络安全
+
+```bash
+# 防火墙配置
+ufw allow 22/tcp    # SSH
+ufw allow 80/tcp    # HTTP
+ufw allow 443/tcp   # HTTPS
+ufw deny 8080/tcp   # 限制内部服务访问
+```
+
+### SSL/TLS 配置
+
+```nginx
+# nginx/ssl.conf
+server {
+    listen 443 ssl http2;
+    server_name hf-repair.yourdomain.com;
+    
+    ssl_certificate /path/to/certificate.crt;
+    ssl_certificate_key /path/to/private.key;
+    
+    location / {
+        proxy_pass http://localhost:8080;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
+```
+
+## 🚀 性能优化
+
+### 资源调优
+
+```yaml
+# docker-compose 性能配置
+services:
+  hf-repair-system:
+    deploy:
+      resources:
+        limits:
+          cpus: '2.0'
+          memory: 2G
+        reservations:
+          cpus: '1.0'
+          memory: 1G
+    ulimits:
+      nofile:
+        soft: 65536
+        hard: 65536
+```
+
+### 缓存配置
+
+```python
+# config/redis.json
+{
+  "redis": {
+    "host": "redis",
+    "port": 6379,
+    "password": "${REDIS_PASSWORD}",
+    "db": 0,
+    "max_connections": 20,
+    "socket_timeout": 5,
+    "socket_connect_timeout": 5
+  }
+}
+```
+
+## 🔄 维护和更新
+
+### 备份策略
+
+```bash
+#!/bin/bash
+# scripts/backup.sh
+
+# 备份数据库
+pg_dump hf_repair > backup_$(date +%Y%m%d_%H%M%S).sql
+
+# 备份配置文件
+tar -czf config_backup_$(date +%Y%m%d_%H%M%S).tar.gz config/
+
+# 备份日志
+find logs/ -name "*.log" -mtime +7 -delete
+```
+
+### 更新流程
+
+```bash
+# 拉取最新代码
+git pull origin main
+
+# 重新构建
+docker-compose build
+
+# 滚动更新
+docker-compose up -d --no-deps hf-repair-system
+
+# 验证更新
+curl http://localhost:8080/health
+```
+
+## 📱 移动端和远程访问
+
+### VPN 配置
+
+```bash
+# 使用 WireGuard 进行安全远程访问
+wg-quick up wg0
+```
+
+### 移动端应用
+
+1. 使用 PWA 技术
+2. 推送通知集成
+3. 离线状态支持
+
+## 🤝 高可用部署
+
+### 多节点部署
+
+```yaml
+# docker-compose.ha.yml
+version: '3.8'
+services:
+  hf-repair-system:
+    image: hf-repair-system:latest
+    deploy:
+      replicas: 3
+      update_config:
+        parallelism: 1
+        delay: 10s
+      restart_policy:
+        condition: on-failure
+    networks:
+      - hf-repair-network
+```
+
+### 负载均衡
+
+```nginx
+# nginx/load-balancer.conf
+upstream hf_repair_backend {
+    server hf-repair-1:8080;
+    server hf-repair-2:8080;
+    server hf-repair-3:8080;
+}
+
+server {
+    listen 80;
+    location / {
+        proxy_pass http://hf_repair_backend;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+    }
+}
+```
+
+## 📋 部署检查清单
+
+- [ ] 环境变量配置完成
+- [ ] 数据库连接正常
+- [ ] Redis 缓存运行正常
+- [ ] HuggingFace Token 有效
+- [ ] Webhook 配置正确
+- [ ] 防火墙规则设置
+- [ ] SSL 证书配置
+- [ ] 监控系统运行
+- [ ] 备份策略实施
+- [ ] 日志轮转配置
+- [ ] 健康检查正常
+- [ ] 性能基准测试完成
+
+## 🆘 故障排除
+
+### 常见问题
+
+1. **服务无法启动**
+   ```bash
+   # 检查日志
+   docker-compose logs hf-repair-system
+   
+   # 检查配置
+   python -m json.tool config.json
+   ```
+
+2. **数据库连接失败**
+   ```bash
+   # 检查数据库状态
+   docker-compose exec postgres pg_isready -U hf_repair
+   
+   # 检查网络连接
+   docker network ls
+   ```
+
+3. **API 限制**
+   ```bash
+   # 检查 Token 权限
+   curl -H "Authorization: Bearer $HF_TOKEN" \
+        https://huggingface.co/api/whoami
+   ```
+
+### 调试模式
+
+```bash
+# 启用调试模式
+export LOG_LEVEL=DEBUG
+export DEBUG=true
+
+# 或修改配置文件
+sed -i 's/"debug": false/"debug": true/' config.json
+```

SYSTEM_SUMMARY.md

@@ -0,0 +1,117 @@
+# 系统总结
+
+我已经为您设计了一个完整的 HuggingFace Spaces 自动化监控和修复系统。以下是系统的核心组件和功能总结：
+
+## 🎯 已完成的核心系统架构
+
+### 1. **核心系统架构** (`core_system.py`)
+- **数据模型**: SpaceStatus, ErrorType, RepairAction 等枚举
+- **接口定义**: HuggingFaceAPI, ErrorAnalyzer, RepairStrategyEngine 等抽象接口
+- **主要系统类**: HFSpaceMonitor, AutoRepairSystem, SmartRepairEngine
+- **状态管理**: RepairHistory, StateManager 数据持久化
+
+### 2. **HuggingFace API 客户端** (`huggingface_client.py`)
+- **API 集成**: 完整的 HuggingFace Spaces API 封装
+- **速率限制**: 内置请求限制器防止 API 超限
+- **Webhook 处理**: 支持实时事件处理
+- **会话管理**: 异步 HTTP 会话优化
+
+### 3. **智能错误分析器** (`error_analyzer.py`)
+- **多模式识别**: 正则表达式 + 上下文分析
+- **错误分类**: 8 种主要错误类型识别
+- **置信度评估**: 基于多种因素的智能评分
+- **专门分析器**: Dockerfile、依赖、环境等专项分析
+
+### 4. **配置管理** (`config_template.json`)
+- **完整配置模板**: 涵盖所有系统组件
+- **环境变量支持**: 安全的配置管理
+- **性能调优**: 可配置的性能参数
+- **监控和通知**: 完整的告警配置
+
+### 5. **部署方案** (`docker-compose.yml`)
+- **容器化部署**: 完整的 Docker Compose 配置
+- **服务编排**: 主应用 + Redis + PostgreSQL + 监控
+- **高可用**: 多副本 + 负载均衡配置
+- **监控栈**: Prometheus + Grafana 集成
+
+### 6. **部署指南** (`DEPLOYMENT.md`)
+- **多部署方式**: Docker, 本地, K8s, 云服务
+- **安全配置**: SSL/TLS, 防火墙, 权限管理
+- **性能优化**: 资源调优, 缓存配置
+- **故障排除**: 常见问题和调试方法
+
+### 7. **使用示例** (`usage_examples.py`)
+- **基本使用**: 简单的监控和修复流程
+- **高级功能**: 自定义工作流, 批量处理
+- **Webhook 集成**: 事件驱动的修复流程
+- **性能监控**: 系统性能指标追踪
+
+## 🏗️ 系统架构特点
+
+### **模块化设计**
+- 清晰的接口定义和组件分离
+- 可插拔的错误分析器和修复策略
+- 独立的配置和状态管理
+
+### **智能错误处理**
+- 多层次的错误识别机制
+- 基于上下文的智能分析
+- 置信度评估和风险控制
+
+### **自动化工作流**
+- 监控 → 分析 → 修复 → 验证的闭环
+- 支持多种修复策略和回滚机制
+- 异步处理和并发控制
+
+### **可扩展性**
+- 支持自定义错误模式和修复规则
+- 插件化的分析器架构
+- 灵活的配置和部署选项
+
+## 🚀 核心功能
+
+### **实时监控**
+- HuggingFace Spaces 状态轮询
+- 日志实时分析
+- Webhook 事件处理
+
+### **智能分析**
+- 8 种错误类型自动识别
+- 上下文感知的错误分析
+- 置信度评估和优先级排序
+
+### **自动修复**
+- Dockerfile 语法修正
+- 依赖版本和源地址调整
+- 环境变量和配置优化
+- 端口和权限问题处理
+
+### **状态管理**
+- 修复历史记录
+- 回滚机制
+- 性能指标追踪
+
+## 📊 技术栈
+
+- **核心**: Python 3.11+, asyncio, aiohttp
+- **数据库**: SQLite (开发) / PostgreSQL (生产)
+- **缓存**: Redis
+- **监控**: Prometheus + Grafana
+- **部署**: Docker + Kubernetes
+- **配置**: JSON/YAML, 环境变量
+
+## 🔧 部署方式
+
+1. **Docker Compose** (推荐): 一键部署完整系统
+2. **本地部署**: 直接 Python 运行
+3. **Kubernetes**: 生产级容器编排
+4. **云服务**: AWS, GCP, Azure 集成
+
+## 📈 预期效果
+
+- **监控效率**: 24/7 自动监控，快速发现问题
+- **修复成功率**: 基于历史数据的智能修复策略
+- **运维成本**: 大幅减少人工干预需求
+- **系统稳定性**: 自动化故障恢复和优化
+
+这个系统提供了完整的 HuggingFace Spaces 监控修复解决方案，具有高度的自动化、智能化和可扩展性。您可以根据具体需求调整配置和部署方式。

config_template.json

@@ -0,0 +1,219 @@
+"""
+配置文件模板
+系统配置和环境设置
+"""
+
+{
+  "system": {
+    "name": "HuggingFace Spaces 自动修复系统",
+    "version": "1.0.0",
+    "log_level": "INFO",
+    "debug": false
+  },
+  
+  "huggingface": {
+    "api_token": "${HF_TOKEN}",
+    "base_url": "https://huggingface.co/api",
+    "rate_limit": {
+      "requests_per_minute": 60,
+      "burst_limit": 10
+    },
+    "timeout": {
+      "api_timeout": 30,
+      "build_timeout": 1800,
+      "log_timeout": 60
+    }
+  },
+  
+  "monitoring": {
+    "check_interval": 60,
+    "max_concurrent_spaces": 10,
+    "retry_attempts": 3,
+    "retry_delay": 30,
+    "health_check": {
+      "enabled": true,
+      "port_check": 7860,
+      "timeout": 10,
+      "retries": 3
+    }
+  },
+  
+  "error_analysis": {
+    "confidence_threshold": 0.7,
+    "max_errors_per_analysis": 20,
+    "context_lines": 10,
+    "pattern_matching": {
+      "enabled": true,
+      "case_sensitive": false,
+      "max_matches": 50
+    },
+    "context_analysis": {
+      "enabled": true,
+      "analyzers": [
+        "dockerfile_syntax",
+        "dependency_install",
+        "environment_config",
+        "port_conflict",
+        "permission_error",
+        "network_connection",
+        "timeout_error",
+        "resource_exceeded"
+      ]
+    }
+  },
+  
+  "repair_strategies": {
+    "max_attempts_per_error": 3,
+    "success_rate_threshold": 0.6,
+    "risk_tolerance": "medium",
+    "backup_enabled": true,
+    "strategies": {
+      "dockerfile_syntax": {
+        "enabled": true,
+        "priority": 1,
+        "auto_apply": true,
+        "risk_level": "medium"
+      },
+      "dependency_install": {
+        "enabled": true,
+        "priority": 2,
+        "auto_apply": true,
+        "risk_level": "low",
+        "fallback_sources": [
+          "https://pypi.tuna.tsinghua.edu.cn/simple",
+          "https://mirrors.aliyun.com/pypi/simple",
+          "https://pypi.douban.com/simple"
+        ]
+      },
+      "environment_config": {
+        "enabled": true,
+        "priority": 3,
+        "auto_apply": true,
+        "risk_level": "low"
+      },
+      "port_conflict": {
+        "enabled": true,
+        "priority": 4,
+        "auto_apply": true,
+        "risk_level": "medium",
+        "alternative_ports": [7861, 7862, 7863, 8080, 8000]
+      },
+      "permission_error": {
+        "enabled": true,
+        "priority": 5,
+        "auto_apply": false,
+        "risk_level": "high"
+      },
+      "network_connection": {
+        "enabled": true,
+        "priority": 6,
+        "auto_apply": false,
+        "risk_level": "medium"
+      },
+      "timeout_error": {
+        "enabled": true,
+        "priority": 7,
+        "auto_apply": true,
+        "risk_level": "low"
+      },
+      "resource_exceeded": {
+        "enabled": true,
+        "priority": 8,
+        "auto_apply": false,
+        "risk_level": "high"
+      }
+    }
+  },
+  
+  "file_operations": {
+    "backup": {
+      "enabled": true,
+      "directory": "./backups",
+      "max_backups": 10,
+      "compression": true
+    },
+    "git": {
+      "enabled": true,
+      "auto_commit": true,
+      "commit_message_prefix": "[Auto-Repair]",
+      "branch_name": "auto-repair",
+      "push_immediately": true
+    },
+    "modification": {
+      "dry_run": false,
+      "confirm_changes": false,
+      "max_file_size_mb": 10
+    }
+  },
+  
+  "database": {
+    "type": "sqlite",
+    "path": "./data/repair_system.db",
+    "backup_enabled": true,
+    "backup_interval_hours": 24,
+    "retention_days": 30
+  },
+  
+  "notifications": {
+    "enabled": true,
+    "channels": {
+      "email": {
+        "enabled": false,
+        "smtp_server": "",
+        "smtp_port": 587,
+        "username": "",
+        "password": "",
+        "recipients": []
+      },
+      "webhook": {
+        "enabled": true,
+        "url": "${WEBHOOK_URL}",
+        "timeout": 10,
+        "retry_attempts": 3
+      },
+      "slack": {
+        "enabled": false,
+        "webhook_url": "",
+        "channel": "#alerts"
+      }
+    },
+    "events": {
+      "repair_success": true,
+      "repair_failed": true,
+      "space_error": true,
+      "build_completed": false,
+      "system_error": true
+    }
+  },
+  
+  "security": {
+    "max_file_access_attempts": 3,
+    "allowed_file_extensions": [".py", ".js", ".json", ".yml", ".yaml", ".md", ".txt"],
+    "forbidden_paths": ["/etc", "/proc", "/sys", "/dev"],
+    "scan_for_secrets": true,
+    "secret_patterns": [
+      "password",
+      "token",
+      "api_key",
+      "secret",
+      "credential"
+    ]
+  },
+  
+  "performance": {
+    "max_concurrent_repairs": 5,
+    "queue_size": 100,
+    "worker_threads": 4,
+    "cache_size_mb": 100,
+    "timeout_per_repair": 600
+  },
+  
+  "logging": {
+    "level": "INFO",
+    "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    "file": "./logs/repair_system.log",
+    "max_file_size_mb": 50,
+    "backup_count": 5,
+    "console_output": true
+  }
+}

core_system.py

@@ -0,0 +1,538 @@
+"""
+HuggingFace Spaces 自动化监控修复系统
+核心系统架构和主要类定义
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any, Tuple, Union
+from enum import Enum
+import asyncio
+import logging
+from datetime import datetime
+import json
+import sqlite3
+import os
+from pathlib import Path
+
+# ============================================================================
+# 数据模型和枚举
+# ============================================================================
+
+class SpaceStatus(Enum):
+    """Space 状态枚举"""
+    BUILDING = "building"
+    RUNNING = "running"
+    STOPPED = "stopped"
+    ERROR = "error"
+    UNKNOWN = "unknown"
+
+class ErrorType(Enum):
+    """错误类型枚举"""
+    DOCKERFILE_SYNTAX = "dockerfile_syntax"
+    DEPENDENCY_INSTALL = "dependency_install"
+    ENVIRONMENT_CONFIG = "environment_config"
+    PORT_CONFLICT = "port_conflict"
+    PERMISSION_ERROR = "permission_error"
+    NETWORK_CONNECTION = "network_connection"
+    TIMEOUT_ERROR = "timeout_error"
+    RESOURCE_EXCEEDED = "resource_exceeded"
+    UNKNOWN_ERROR = "unknown_error"
+
+class RepairAction(Enum):
+    """修复动作枚举"""
+    MODIFY_DOCKERFILE = "modify_dockerfile"
+    UPDATE_DEPENDENCIES = "update_dependencies"
+    FIX_ENVIRONMENT = "fix_environment"
+    CHANGE_PORT = "change_port"
+    SET_PERMISSIONS = "set_permissions"
+    UPDATE_SOURCES = "update_sources"
+    ADJUST_RESOURCES = "adjust_resources"
+    RETRY_BUILD = "retry_build"
+
+@dataclass
+class SpaceInfo:
+    """Space 信息"""
+    space_id: str
+    name: str
+    repository_url: str
+    current_status: SpaceStatus
+    last_updated: datetime
+    dockerfile_path: str = "Dockerfile"
+    local_path: str = ""
+
+@dataclass
+class ErrorInfo:
+    """错误信息"""
+    error_type: ErrorType
+    message: str
+    log_snippet: str
+    line_number: Optional[int] = None
+    confidence: float = 0.0
+    context: Dict[str, Any] = field(default_factory=dict)
+
+@dataclass
+class RepairStrategy:
+    """修复策略"""
+    action: RepairAction
+    description: str
+    modifications: Dict[str, Any]
+    risk_level: str  # low, medium, high
+    success_rate: float = 0.0
+    estimated_time: int = 0  # 秒
+
+@dataclass
+class RepairHistory:
+    """修复历史"""
+    id: int
+    space_id: str
+    timestamp: datetime
+    error_info: ErrorInfo
+    strategy: RepairStrategy
+    success: bool
+    git_commit: Optional[str] = None
+    rollback_data: Optional[str] = None
+
+# ============================================================================
+# 核心接口定义
+# ============================================================================
+
+class HuggingFaceAPI(ABC):
+    """HuggingFace API 接口"""
+    
+    @abstractmethod
+    async def get_space_status(self, space_id: str) -> SpaceStatus:
+        """获取 Space 状态"""
+        pass
+    
+    @abstractmethod
+    async def get_space_logs(self, space_id: str, lines: int = 100) -> str:
+        """获取 Space 日志"""
+        pass
+    
+    @abstractmethod
+    async def trigger_rebuild(self, space_id: str) -> bool:
+        """触发重新构建"""
+        pass
+    
+    @abstractmethod
+    async def get_space_info(self, space_id: str) -> SpaceInfo:
+        """获取 Space 详细信息"""
+        pass
+
+class ErrorAnalyzer(ABC):
+    """错误分析器接口"""
+    
+    @abstractmethod
+    async def analyze_logs(self, logs: str) -> List[ErrorInfo]:
+        """分析日志并识别错误"""
+        pass
+    
+    @abstractmethod
+    async def classify_error(self, error_message: str) -> ErrorType:
+        """分类错误类型"""
+        pass
+
+class RepairStrategyEngine(ABC):
+    """修复策略引擎接口"""
+    
+    @abstractmethod
+    async def generate_strategy(self, error: ErrorInfo, space_info: SpaceInfo) -> Optional[RepairStrategy]:
+        """生成修复策略"""
+        pass
+    
+    @abstractmethod
+    async def estimate_success(self, strategy: RepairStrategy) -> float:
+        """估算成功概率"""
+        pass
+
+class FileModifier(ABC):
+    """文件修改器接口"""
+    
+    @abstractmethod
+    async def apply_modifications(self, file_path: str, modifications: Dict[str, Any]) -> bool:
+        """应用修改"""
+        pass
+    
+    @abstractmethod
+    async def backup_file(self, file_path: str) -> str:
+        """备份文件"""
+        pass
+
+# ============================================================================
+# 核心系统类
+# ============================================================================
+
+class HFSpaceMonitor:
+    """HuggingFace Space 监控器"""
+    
+    def __init__(self, hf_api: HuggingFaceAPI, check_interval: int = 60):
+        self.hf_api = hf_api
+        self.check_interval = check_interval
+        self.logger = logging.getLogger(__name__)
+        self._running = False
+    
+    async def start_monitoring(self, space_ids: List[str]) -> None:
+        """开始监控 Spaces"""
+        self._running = True
+        self.logger.info(f"开始监控 {len(space_ids)} 个 Space")
+        
+        while self._running:
+            try:
+                await self._check_spaces(space_ids)
+                await asyncio.sleep(self.check_interval)
+            except Exception as e:
+                self.logger.error(f"监控过程出错: {e}")
+                await asyncio.sleep(5)
+    
+    async def _check_spaces(self, space_ids: List[str]) -> None:
+        """检查所有 Space 状态"""
+        tasks = [self._check_single_space(space_id) for space_id in space_ids]
+        await asyncio.gather(*tasks, return_exceptions=True)
+    
+    async def _check_single_space(self, space_id: str) -> None:
+        """检查单个 Space 状态"""
+        try:
+            status = await self.hf_api.get_space_status(space_id)
+            self.logger.info(f"Space {space_id} 状态: {status.value}")
+            
+            if status == SpaceStatus.ERROR:
+                logs = await self.hf_api.get_space_logs(space_id)
+                # 触发错误分析和修复流程
+                await self._handle_error(space_id, logs)
+                
+        except Exception as e:
+            self.logger.error(f"检查 Space {space_id} 失败: {e}")
+    
+    async def _handle_error(self, space_id: str, logs: str) -> None:
+        """处理错误"""
+        # 这里会调用错误分析器和修复引擎
+        pass
+    
+    def stop(self) -> None:
+        """停止监控"""
+        self._running = False
+
+class IntelligentErrorAnalyzer:
+    """智能错误分析器"""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.error_patterns = self._load_error_patterns()
+    
+    async def analyze_logs(self, logs: str) -> List[ErrorInfo]:
+        """分析日志并识别错误"""
+        errors = []
+        
+        # 分行分析日志
+        for line_num, line in enumerate(logs.split('\n'), 1):
+            for error_type, patterns in self.error_patterns.items():
+                for pattern in patterns:
+                    if pattern['regex'].search(line):
+                        error_info = ErrorInfo(
+                            error_type=ErrorType(error_type),
+                            message=line.strip(),
+                            log_snippet=line.strip(),
+                            line_number=line_num,
+                            confidence=pattern['confidence'],
+                            context=self._extract_context(line, logs, line_num)
+                        )
+                        errors.append(error_info)
+                        break
+        
+        return errors
+    
+    def _load_error_patterns(self) -> Dict[str, List[Dict]]:
+        """加载错误模式"""
+        return {
+            "dockerfile_syntax": [
+                {
+                    "regex": re.compile(r"ERROR:.*failed to solve|failed to compute cache key"),
+                    "confidence": 0.9
+                }
+            ],
+            "dependency_install": [
+                {
+                    "regex": re.compile(r"ERROR:.*Could not find a version|No matching distribution"),
+                    "confidence": 0.85
+                }
+            ],
+            "environment_config": [
+                {
+                    "regex": re.compile(r"ERROR:.*environment variable|ENV not found"),
+                    "confidence": 0.8
+                }
+            ]
+            # 更多模式...
+        }
+    
+    def _extract_context(self, error_line: str, logs: str, line_num: int) -> Dict[str, Any]:
+        """提取错误上下文"""
+        lines = logs.split('\n')
+        start = max(0, line_num - 3)
+        end = min(len(lines), line_num + 3)
+        
+        return {
+            "before": lines[start:line_num],
+            "after": lines[line_num + 1:end],
+            "full_context": lines[start:end]
+        }
+
+class SmartRepairEngine:
+    """智能修复引擎"""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.repair_rules = self._load_repair_rules()
+    
+    async def generate_strategy(self, error: ErrorInfo, space_info: SpaceInfo) -> Optional[RepairStrategy]:
+        """生成修复策略"""
+        error_type = error.error_type.value
+        
+        if error_type in self.repair_rules:
+            rules = self.repair_rules[error_type]
+            # 选择最适合的规则
+            best_rule = max(rules, key=lambda r: r['success_rate'])
+            
+            return RepairStrategy(
+                action=RepairAction(best_rule['action']),
+                description=best_rule['description'],
+                modifications=best_rule['modifications'],
+                risk_level=best_rule['risk_level'],
+                success_rate=best_rule['success_rate'],
+                estimated_time=best_rule['estimated_time']
+            )
+        
+        return None
+    
+    def _load_repair_rules(self) -> Dict[str, List[Dict]]:
+        """加载修复规则"""
+        return {
+            "dockerfile_syntax": [
+                {
+                    "action": "modify_dockerfile",
+                    "description": "修复 Dockerfile 语法错误",
+                    "modifications": {
+                        "type": "syntax_fix",
+                        "target": error.line_number
+                    },
+                    "risk_level": "medium",
+                    "success_rate": 0.7,
+                    "estimated_time": 120
+                }
+            ],
+            "dependency_install": [
+                {
+                    "action": "update_dependencies",
+                    "description": "更新依赖版本或更换源地址",
+                    "modifications": {
+                        "type": "dependency_update",
+                        "strategy": "version_bump_or_source_change"
+                    },
+                    "risk_level": "low",
+                    "success_rate": 0.8,
+                    "estimated_time": 300
+                }
+            ]
+            # 更多规则...
+        }
+
+class AutoRepairSystem:
+    """自动修复系统主类"""
+    
+    def __init__(self, config_path: str = "config.json"):
+        self.config = self._load_config(config_path)
+        self.logger = self._setup_logging()
+        
+        # 初始化各个组件
+        self.hf_api = HuggingFaceAPIClient(self.config['hf_token'])
+        self.error_analyzer = IntelligentErrorAnalyzer()
+        self.repair_engine = SmartRepairEngine()
+        self.file_modifier = DockerfileModifier()
+        self.state_manager = StateManager(self.config['db_path'])
+        
+        # 监控器
+        self.monitor = HFSpaceMonitor(self.hf_api, self.config['check_interval'])
+        
+        # 修复队列
+        self.repair_queue = asyncio.Queue()
+    
+    async def start(self, space_ids: List[str]) -> None:
+        """启动系统"""
+        self.logger.info("启动 HuggingFace Spaces 自动修复系统")
+        
+        # 启动监控任务
+        monitor_task = asyncio.create_task(self.monitor.start_monitoring(space_ids))
+        
+        # 启动修复任务
+        repair_task = asyncio.create_task(self._process_repair_queue())
+        
+        # 等待任务完成（正常情况下不会完成）
+        await asyncio.gather(monitor_task, repair_task)
+    
+    async def _process_repair_queue(self) -> None:
+        """处理修复队列"""
+        while True:
+            try:
+                repair_job = await self.repair_queue.get()
+                await self._execute_repair(repair_job)
+            except Exception as e:
+                self.logger.error(f"修复任务执行失败: {e}")
+    
+    async def _execute_repair(self, job: Dict[str, Any]) -> None:
+        """执行修复任务"""
+        space_id = job['space_id']
+        error_info = job['error_info']
+        
+        self.logger.info(f"开始修复 Space {space_id}")
+        
+        # 获取 Space 信息
+        space_info = await self.hf_api.get_space_info(space_id)
+        
+        # 生成修复策略
+        strategy = await self.repair_engine.generate_strategy(error_info, space_info)
+        
+        if strategy:
+            try:
+                # 备份原文件
+                backup_path = await self.file_modifier.backup_file(space_info.dockerfile_path)
+                
+                # 应用修改
+                success = await self.file_modifier.apply_modifications(
+                    space_info.dockerfile_path, 
+                    strategy.modifications
+                )
+                
+                if success:
+                    # 提交到 Git
+                    git_commit = await self._commit_changes(space_id, strategy)
+                    
+                    # 触发重新构建
+                    await self.hf_api.trigger_rebuild(space_id)
+                    
+                    # 记录历史
+                    await self.state_manager.record_repair(
+                        space_id, error_info, strategy, True, git_commit
+                    )
+                    
+                    self.logger.info(f"Space {space_id} 修复完成")
+                else:
+                    # 回滚
+                    await self._rollback(backup_path, space_info.dockerfile_path)
+                    
+            except Exception as e:
+                self.logger.error(f"修复失败: {e}")
+                await self._rollback(backup_path, space_info.dockerfile_path)
+    
+    def _load_config(self, config_path: str) -> Dict[str, Any]:
+        """加载配置"""
+        default_config = {
+            "hf_token": os.getenv("HF_TOKEN", ""),
+            "check_interval": 60,
+            "db_path": "repair_system.db",
+            "max_retry": 3,
+            "log_level": "INFO"
+        }
+        
+        if os.path.exists(config_path):
+            with open(config_path, 'r') as f:
+                user_config = json.load(f)
+                default_config.update(user_config)
+        
+        return default_config
+    
+    def _setup_logging(self) -> logging.Logger:
+        """设置日志"""
+        logger = logging.getLogger(__name__)
+        logger.setLevel(getattr(logging, self.config['log_level']))
+        
+        handler = logging.StreamHandler()
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        )
+        handler.setFormatter(formatter)
+        logger.addHandler(handler)
+        
+        return logger
+
+# ============================================================================
+# 具体实现类
+# ============================================================================
+
+class HuggingFaceAPIClient(HuggingFaceAPI):
+    """HuggingFace API 客户端实现"""
+    
+    def __init__(self, token: str):
+        self.token = token
+        self.base_url = "https://huggingface.co/api"
+        self.headers = {"Authorization": f"Bearer {token}"}
+    
+    async def get_space_status(self, space_id: str) -> SpaceStatus:
+        """获取 Space 状态"""
+        # 实现具体的 API 调用逻辑
+        pass
+    
+    async def get_space_logs(self, space_id: str, lines: int = 100) -> str:
+        """获取 Space 日志"""
+        # 实现具体的 API 调用逻辑
+        pass
+    
+    async def trigger_rebuild(self, space_id: str) -> bool:
+        """触发重新构建"""
+        # 实现具体的 API 调用逻辑
+        pass
+    
+    async def get_space_info(self, space_id: str) -> SpaceInfo:
+        """获取 Space 详细信息"""
+        # 实现具体的 API 调用逻辑
+        pass
+
+class DockerfileModifier(FileModifier):
+    """Dockerfile 修改器实现"""
+    
+    async def apply_modifications(self, file_path: str, modifications: Dict[str, Any]) -> bool:
+        """应用修改"""
+        # 实现具体的 Dockerfile 修改逻辑
+        pass
+    
+    async def backup_file(self, file_path: str) -> str:
+        """备份文件"""
+        # 实现文件备份逻辑
+        pass
+
+class StateManager:
+    """状态管理器"""
+    
+    def __init__(self, db_path: str):
+        self.db_path = db_path
+        self._init_database()
+    
+    def _init_database(self) -> None:
+        """初始化数据库"""
+        # 创建数据库表结构
+        pass
+    
+    async def record_repair(self, space_id: str, error_info: ErrorInfo, 
+                          strategy: RepairStrategy, success: bool, 
+                          git_commit: Optional[str] = None) -> None:
+        """记录修复历史"""
+        # 实现修复历史记录逻辑
+        pass
+    
+    async def get_repair_history(self, space_id: str) -> List[RepairHistory]:
+        """获取修复历史"""
+        # 实现历史查询逻辑
+        pass
+
+if __name__ == "__main__":
+    # 系统启动示例
+    system = AutoRepairSystem()
+    
+    # 要监控的 Space ID 列表
+    space_ids = [
+        "your-username/your-space-1",
+        "your-username/your-space-2"
+    ]
+    
+    # 启动系统
+    asyncio.run(system.start(space_ids))

docker-compose.yml

@@ -0,0 +1,143 @@
+"""
+部署方案和启动脚本
+包含 Docker 部署、本地部署和系统服务配置
+"""
+
+version: '3.8'
+
+services:
+  # 主应用服务
+  hf-repair-system:
+    build:
+      context: .
+      dockerfile: Dockerfile.repair
+    container_name: hf-repair-system
+    restart: unless-stopped
+    environment:
+      - HF_TOKEN=${HF_TOKEN}
+      - WEBHOOK_URL=${WEBHOOK_URL}
+      - DB_PATH=/app/data/repair_system.db
+      - LOG_LEVEL=INFO
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - ./backups:/app/backups
+      - ./config:/app/config
+    ports:
+      - "8080:8080"
+    networks:
+      - hf-repair-network
+    depends_on:
+      - redis
+      - postgres
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+  # Redis 缓存服务
+  redis:
+    image: redis:7-alpine
+    container_name: hf-repair-redis
+    restart: unless-stopped
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    networks:
+      - hf-repair-network
+    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD}
+    healthcheck:
+      test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  # PostgreSQL 数据库服务
+  postgres:
+    image: postgres:15-alpine
+    container_name: hf-repair-postgres
+    restart: unless-stopped
+    environment:
+      - POSTGRES_DB=hf_repair
+      - POSTGRES_USER=hf_repair
+      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+      - ./sql/init.sql:/docker-entrypoint-initdb.d/init.sql
+    networks:
+      - hf-repair-network
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U hf_repair"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+
+  # Web 服务（可选的 Web 界面）
+  web-interface:
+    build:
+      context: ./web
+      dockerfile: Dockerfile
+    container_name: hf-repair-web
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    environment:
+      - REACT_APP_API_URL=http://localhost:8080
+    networks:
+      - hf-repair-network
+    depends_on:
+      - hf-repair-system
+
+  # 监控服务
+  prometheus:
+    image: prom/prometheus:latest
+    container_name: hf-repair-prometheus
+    restart: unless-stopped
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
+      - prometheus_data:/prometheus
+    networks:
+      - hf-repair-network
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--web.console.libraries=/etc/prometheus/console_libraries'
+      - '--web.console.templates=/etc/prometheus/consoles'
+
+  # Grafana 可视化
+  grafana:
+    image: grafana/grafana:latest
+    container_name: hf-repair-grafana
+    restart: unless-stopped
+    ports:
+      - "3001:3000"
+    environment:
+      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
+    volumes:
+      - grafana_data:/var/lib/grafana
+      - ./monitoring/grafana:/etc/grafana/provisioning
+    networks:
+      - hf-repair-network
+    depends_on:
+      - prometheus
+
+volumes:
+  redis_data:
+    driver: local
+  postgres_data:
+    driver: local
+  prometheus_data:
+    driver: local
+  grafana_data:
+    driver: local
+
+networks:
+  hf-repair-network:
+    driver: bridge

error_analyzer.py

@@ -0,0 +1,504 @@
+"""
+错误分析器实现
+负责分析日志、识别错误类型和根本原因
+"""
+
+import re
+import asyncio
+import logging
+from typing import List, Dict, Any, Tuple, Optional
+from dataclasses import dataclass
+from datetime import datetime
+
+from core_system import ErrorAnalyzer, ErrorInfo, ErrorType
+
+@dataclass
+class ErrorPattern:
+    """错误模式定义"""
+    regex: re.Pattern
+    error_type: ErrorType
+    confidence: float
+    description: str
+    common_causes: List[str]
+    suggested_fixes: List[str]
+
+class LogAnalyzer:
+    """日志分析器"""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+    
+    def extract_error_context(self, logs: str, error_line: int, context_size: int = 5) -> Dict[str, Any]:
+        """提取错误上下文"""
+        lines = logs.split('\n')
+        start = max(0, error_line - context_size)
+        end = min(len(lines), error_line + context_size + 1)
+        
+        return {
+            "before": lines[start:error_line],
+            "error_line": lines[error_line] if error_line < len(lines) else "",
+            "after": lines[error_line + 1:end],
+            "full_context": lines[start:end],
+            "relative_line": error_line - start
+        }
+    
+    def detect_error_sequence(self, logs: str) -> List[str]:
+        """检测错误序列"""
+        lines = logs.split('\n')
+        error_sequence = []
+        
+        for line in lines:
+            if any(keyword in line.lower() for keyword in ['error', 'failed', 'exception', 'traceback']):
+                error_sequence.append(line.strip())
+        
+        return error_sequence
+    
+    def find_related_errors(self, logs: str, main_error: ErrorInfo) -> List[ErrorInfo]:
+        """查找相关错误"""
+        related_errors = []
+        lines = logs.split('\n')
+        
+        # 在主错误附近查找相关错误
+        if main_error.line_number:
+            start = max(0, main_error.line_number - 10)
+            end = min(len(lines), main_error.line_number + 10)
+            
+            for i, line in enumerate(lines[start:end], start):
+                if i != main_error.line_number and 'error' in line.lower():
+                    related_error = ErrorInfo(
+                        error_type=ErrorType.UNKNOWN_ERROR,
+                        message=line.strip(),
+                        log_snippet=line.strip(),
+                        line_number=i,
+                        confidence=0.5
+                    )
+                    related_errors.append(related_error)
+        
+        return related_errors
+
+class IntelligentErrorAnalyzer(ErrorAnalyzer):
+    """智能错误分析器"""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+        self.log_analyzer = LogAnalyzer()
+        self.error_patterns = self._initialize_patterns()
+        self.context_analyzers = {
+            ErrorType.DOCKERFILE_SYNTAX: DockerfileSyntaxAnalyzer(),
+            ErrorType.DEPENDENCY_INSTALL: DependencyErrorAnalyzer(),
+            ErrorType.ENVIRONMENT_CONFIG: EnvironmentErrorAnalyzer(),
+            ErrorType.PORT_CONFLICT: PortErrorAnalyzer(),
+            ErrorType.PERMISSION_ERROR: PermissionErrorAnalyzer(),
+            ErrorType.NETWORK_CONNECTION: NetworkErrorAnalyzer(),
+            ErrorType.TIMEOUT_ERROR: TimeoutErrorAnalyzer(),
+            ErrorType.RESOURCE_EXCEEDED: ResourceErrorAnalyzer()
+        }
+    
+    async def analyze_logs(self, logs: str) -> List[ErrorInfo]:
+        """分析日志并识别错误"""
+        errors = []
+        
+        # 首先使用正则模式进行快速匹配
+        pattern_errors = await self._pattern_matching(logs)
+        errors.extend(pattern_errors)
+        
+        # 然后使用上下文分析器进行深度分析
+        context_errors = await self._context_analysis(logs)
+        errors.extend(context_errors)
+        
+        # 去重和合并相似错误
+        deduplicated_errors = self._deduplicate_errors(errors)
+        
+        # 计算最终置信度
+        final_errors = self._calculate_final_confidence(deduplicated_errors, logs)
+        
+        return final_errors
+    
+    async def classify_error(self, error_message: str) -> ErrorType:
+        """分类错误类型"""
+        max_confidence = 0.0
+        best_type = ErrorType.UNKNOWN_ERROR
+        
+        for pattern in self.error_patterns:
+            if pattern.regex.search(error_message):
+                if pattern.confidence > max_confidence:
+                    max_confidence = pattern.confidence
+                    best_type = pattern.error_type
+        
+        return best_type
+    
+    async def _pattern_matching(self, logs: str) -> List[ErrorInfo]:
+        """基于模式的错误匹配"""
+        errors = []
+        lines = logs.split('\n')
+        
+        for line_num, line in enumerate(lines, 1):
+            for pattern in self.error_patterns:
+                if pattern.regex.search(line):
+                    error_info = ErrorInfo(
+                        error_type=pattern.error_type,
+                        message=line.strip(),
+                        log_snippet=line.strip(),
+                        line_number=line_num,
+                        confidence=pattern.confidence,
+                        context={
+                            "description": pattern.description,
+                            "common_causes": pattern.common_causes,
+                            "suggested_fixes": pattern.suggested_fixes
+                        }
+                    )
+                    errors.append(error_info)
+        
+        return errors
+    
+    async def _context_analysis(self, logs: str) -> List[ErrorInfo]:
+        """上下文感知的错误分析"""
+        errors = []
+        
+        for error_type, analyzer in self.context_analyzers.items():
+            try:
+                type_errors = await analyzer.analyze(logs)
+                errors.extend(type_errors)
+            except Exception as e:
+                self.logger.error(f"上下文分析器 {error_type} 执行失败: {e}")
+        
+        return errors
+    
+    def _deduplicate_errors(self, errors: List[ErrorInfo]) -> List[ErrorInfo]:
+        """去重错误"""
+        if not errors:
+            return []
+        
+        # 按行号和错误类型去重
+        seen = set()
+        deduplicated = []
+        
+        for error in errors:
+            key = (error.line_number, error.error_type)
+            if key not in seen:
+                seen.add(key)
+                deduplicated.append(error)
+        
+        return deduplicated
+    
+    def _calculate_final_confidence(self, errors: List[ErrorInfo], logs: str) -> List[ErrorInfo]:
+        """计算最终置信度"""
+        for error in errors:
+            # 基于多种因素调整置信度
+            base_confidence = error.confidence
+            
+            # 如果错误信息中包含具体的技术关键词，提高置信度
+            tech_keywords = ['docker', 'pip', 'npm', 'apt', 'python', 'node']
+            keyword_boost = sum(0.1 for keyword in tech_keywords if keyword in error.message.lower())
+            
+            # 如果错误在日志的末尾（最近的错误），提高置信度
+            lines = logs.split('\n')
+            position_factor = (error.line_number or 0) / len(lines) if len(lines) > 0 else 0.5
+            recent_boost = (1 - position_factor) * 0.2
+            
+            # 计算最终置信度
+            final_confidence = min(1.0, base_confidence + keyword_boost + recent_boost)
+            error.confidence = final_confidence
+        
+        return errors
+    
+    def _initialize_patterns(self) -> List[ErrorPattern]:
+        """初始化错误模式"""
+        patterns = [
+            # Dockerfile 语法错误
+            ErrorPattern(
+                regex=re.compile(r"failed to solve:.*syntax error|Dockerfile:\d+"),
+                error_type=ErrorType.DOCKERFILE_SYNTAX,
+                confidence=0.9,
+                description="Dockerfile 语法错误",
+                common_causes=["命令格式错误", "参数缺失", "缩进问题"],
+                suggested_fixes=["检查命令语法", "验证参数", "修复格式"]
+            ),
+            
+            # 依赖安装失败
+            ErrorPattern(
+                regex=re.compile(r"ERROR: Could not find a version|No matching distribution|pip install failed"),
+                error_type=ErrorType.DEPENDENCY_INSTALL,
+                confidence=0.85,
+                description="Python 依赖安装失败",
+                common_causes=["版本不存在", "网络问题", "依赖冲突"],
+                suggested_fixes=["检查版本", "更换源", "解决冲突"]
+            ),
+            
+            # Node.js 依赖安装失败
+            ErrorPattern(
+                regex=re.compile(r"npm ERR!|yarn error|failed to install node packages"),
+                error_type=ErrorType.DEPENDENCY_INSTALL,
+                confidence=0.85,
+                description="Node.js 依赖安装失败",
+                common_causes=["版本冲突", "网络问题", "缓存问题"],
+                suggested_fixes=["清理缓存", "检查版本", "使用国内源"]
+            ),
+            
+            # 环境变量配置问题
+            ErrorPattern(
+                regex=re.compile(r"Environment variable.*not found|ENV.*undefined|getenv.*None"),
+                error_type=ErrorType.ENVIRONMENT_CONFIG,
+                confidence=0.8,
+                description="环境变量配置问题",
+                common_causes=["变量未设置", "配置文件缺失", "权限问题"],
+                suggested_fixes=["设置环境变量", "创建配置文件", "检查权限"]
+            ),
+            
+            # 端口冲突
+            ErrorPattern(
+                regex=re.compile(r"Address already in use|Port.*already used|EADDRINUSE"),
+                error_type=ErrorType.PORT_CONFLICT,
+                confidence=0.95,
+                description="端口冲突",
+                common_causes=["端口被占用", "权限不足", "配置错误"],
+                suggested_fixes=["更换端口", "杀死占用进程", "修改配置"]
+            ),
+            
+            # 权限问题
+            ErrorPattern(
+                regex=re.compile(r"Permission denied|Operation not permitted|EACCES"),
+                error_type=ErrorType.PERMISSION_ERROR,
+                confidence=0.9,
+                description="权限不足",
+                common_causes=["文件权限", "用户权限", "目录权限"],
+                suggested_fixes=["修改权限", "使用 sudo", "更改用户"]
+            ),
+            
+            # 网络连接问题
+            ErrorPattern(
+                regex=re.compile(r"Connection refused|Network unreachable|Timeout|DNS resolution failed"),
+                error_type=ErrorType.NETWORK_CONNECTION,
+                confidence=0.8,
+                description="网络连接问题",
+                common_causes=["网络不可达", "DNS问题", "防火墙限制"],
+                suggested_fixes=["检查网络", "配置DNS", "调整防火墙"]
+            ),
+            
+            # 超时错误
+            ErrorPattern(
+                regex=re.compile(r"timeout|timed out|deadline exceeded"),
+                error_type=ErrorType.TIMEOUT_ERROR,
+                confidence=0.75,
+                description="操作超时",
+                common_causes=["操作时间过长", "资源不足", "网络延迟"],
+                suggested_fixes["增加超时时间", "优化性能", "检查资源"]
+            ),
+            
+            # 资源超限
+            ErrorPattern(
+                regex=re.compile(r"out of memory|disk full|CPU limit exceeded|resource exceeded"),
+                error_type=ErrorType.RESOURCE_EXCEEDED,
+                confidence=0.9,
+                description="资源超限",
+                common_causes=["内存不足", "磁盘满", "CPU限制"],
+                suggested_fixes=["清理资源", "增加配额", "优化代码"]
+            )
+        ]
+        
+        return patterns
+
+class ContextAnalyzer(ABC):
+    """上下文分析器基类"""
+    
+    async def analyze(self, logs: str) -> List[ErrorInfo]:
+        """分析日志"""
+        pass
+
+class DockerfileSyntaxAnalyzer(ContextAnalyzer):
+    """Dockerfile 语法分析器"""
+    
+    async def analyze(self, logs: str) -> List[ErrorInfo]:
+        errors = []
+        
+        # 分析 Dockerfile 特有的语法错误
+        dockerfile_errors = [
+            (r"FROM.*invalid", "FROM 指令格式错误"),
+            (r"RUN.*command not found", "RUN 命令执行失败"),
+            (r"COPY.*No such file", "COPY 源文件不存在"),
+            (r"EXPOSE.*invalid port", "EXPOSE 端口格式错误"),
+            (r"ENV.*invalid format", "ENV 环境变量格式错误")
+        ]
+        
+        for pattern, description in dockerfile_errors:
+            if re.search(pattern, logs, re.IGNORECASE):
+                error_info = ErrorInfo(
+                    error_type=ErrorType.DOCKERFILE_SYNTAX,
+                    message=description,
+                    log_snippet="",
+                    confidence=0.8,
+                    context={"analysis_type": "dockerfile_syntax"}
+                )
+                errors.append(error_info)
+        
+        return errors
+
+class DependencyErrorAnalyzer(ContextAnalyzer):
+    """依赖错误分析器"""
+    
+    async def analyze(self, logs: str) -> List[ErrorInfo]:
+        errors = []
+        
+        # Python 依赖问题
+        python_patterns = [
+            (r"pip.*Requirement already satisfied", "依赖重复安装"),
+            (r"pip.*Could not find.*version", "依赖版本不存在"),
+            (r"pip.*incompatible dependencies", "依赖版本冲突")
+        ]
+        
+        # Node.js 依赖问题
+        node_patterns = [
+            (r"npm.*peer dependency", "peer 依赖问题"),
+            (r"npm.*version mismatch", "版本不匹配"),
+            (r"npm.*cache problem", "npm 缓存问题")
+        ]
+        
+        all_patterns = python_patterns + node_patterns
+        
+        for pattern, description in all_patterns:
+            if re.search(pattern, logs, re.IGNORECASE):
+                error_info = ErrorInfo(
+                    error_type=ErrorType.DEPENDENCY_INSTALL,
+                    message=description,
+                    log_snippet="",
+                    confidence=0.75,
+                    context={"analysis_type": "dependency"}
+                )
+                errors.append(error_info)
+        
+        return errors
+
+class EnvironmentErrorAnalyzer(ContextAnalyzer):
+    """环境错误分析器"""
+    
+    async def analyze(self, logs: str) -> List[ErrorInfo]:
+        errors = []
+        
+        # 环境变量问题
+        if re.search(r"PATH.*not found", logs, re.IGNORECASE):
+            error_info = ErrorInfo(
+                error_type=ErrorType.ENVIRONMENT_CONFIG,
+                message="PATH 环境变量配置问题",
+                log_snippet="",
+                confidence=0.8,
+                context={"analysis_type": "environment", "var_type": "PATH"}
+            )
+            errors.append(error_info)
+        
+        return errors
+
+class PortErrorAnalyzer(ContextAnalyzer):
+    """端口错误分析器"""
+    
+    async def analyze(self, logs: str) -> List[ErrorInfo]:
+        errors = []
+        
+        # 检测常见的 HuggingFace Spaces 端口问题
+        if re.search(r"port.*7860", logs, re.IGNORECASE) and re.search(r"error|failed", logs, re.IGNORECASE):
+            error_info = ErrorInfo(
+                error_type=ErrorType.PORT_CONFLICT,
+                message="HuggingFace Spaces 默认端口 7860 问题",
+                log_snippet="",
+                confidence=0.9,
+                context={"analysis_type": "port", "port": "7860"}
+            )
+            errors.append(error_info)
+        
+        return errors
+
+class PermissionErrorAnalyzer(ContextAnalyzer):
+    """权限错误分析器"""
+    
+    async def analyze(self, logs: str) -> List[ErrorInfo]:
+        errors = []
+        
+        # 检测文件权限问题
+        if re.search(r"permission denied.*\.py|\.js|\.sh", logs, re.IGNORECASE):
+            error_info = ErrorInfo(
+                error_type=ErrorType.PERMISSION_ERROR,
+                message="脚本文件权限问题",
+                log_snippet="",
+                confidence=0.8,
+                context={"analysis_type": "permission", "file_type": "script"}
+            )
+            errors.append(error_info)
+        
+        return errors
+
+class NetworkErrorAnalyzer(ContextAnalyzer):
+    """网络错误分析器"""
+    
+    async def analyze(self, logs: str) -> List[ErrorInfo]:
+        errors = []
+        
+        # 检测网络连接问题
+        network_indicators = [
+            (r"github\.com.*timeout", "GitHub 连接超时"),
+            (r"pypi\.org.*failed", "PyPI 连接失败"),
+            (r"npm\.registry.*error", "npm registry 连接错误")
+        ]
+        
+        for pattern, description in network_indicators:
+            if re.search(pattern, logs, re.IGNORECASE):
+                error_info = ErrorInfo(
+                    error_type=ErrorType.NETWORK_CONNECTION,
+                    message=description,
+                    log_snippet="",
+                    confidence=0.7,
+                    context={"analysis_type": "network", "service": pattern.split('.')[0]}
+                )
+                errors.append(error_info)
+        
+        return errors
+
+class TimeoutErrorAnalyzer(ContextAnalyzer):
+    """超时错误分析器"""
+    
+    async def analyze(self, logs: str) -> List[ErrorInfo]:
+        errors = []
+        
+        # 检测不同类型的超时
+        timeout_patterns = [
+            (r"build.*timeout", "构建超时"),
+            (r"install.*timeout", "安装超时"),
+            (r"download.*timeout", "下载超时")
+        ]
+        
+        for pattern, description in timeout_patterns:
+            if re.search(pattern, logs, re.IGNORECASE):
+                error_info = ErrorInfo(
+                    error_type=ErrorType.TIMEOUT_ERROR,
+                    message=description,
+                    log_snippet="",
+                    confidence=0.8,
+                    context={"analysis_type": "timeout", "operation": pattern.split('.')[0]}
+                )
+                errors.append(error_info)
+        
+        return errors
+
+class ResourceErrorAnalyzer(ContextAnalyzer):
+    """资源错误分析器"""
+    
+    async def analyze(self, logs: str) -> List[ErrorInfo]:
+        errors = []
+        
+        # 检测资源限制问题
+        resource_patterns = [
+            (r"memory.*limit", "内存限制"),
+            (r"disk.*space", "磁盘空间不足"),
+            (r"cpu.*quota", "CPU 配额限制")
+        ]
+        
+        for pattern, description in resource_patterns:
+            if re.search(pattern, logs, re.IGNORECASE):
+                error_info = ErrorInfo(
+                    error_type=ErrorType.RESOURCE_EXCEEDED,
+                    message=description,
+                    log_snippet="",
+                    confidence=0.8,
+                    context={"analysis_type": "resource", "resource_type": pattern.split('.')[0]}
+                )
+                errors.append(error_info)
+        
+        return errors

huggingface_client.py

@@ -0,0 +1,289 @@
+"""
+HuggingFace Spaces API 客户端实现
+负责与 HuggingFace API 的所有交互
+"""
+
+import aiohttp
+import asyncio
+import logging
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from dataclasses import asdict
+import json
+
+from core_system import HuggingFaceAPI, SpaceInfo, SpaceStatus, ErrorInfo
+
+class HuggingFaceAPIClient(HuggingFaceAPI):
+    """HuggingFace API 客户端实现"""
+    
+    def __init__(self, token: str):
+        self.token = token
+        self.base_url = "https://huggingface.co/api"
+        self.headers = {"Authorization": f"Bearer {token}"}
+        self.logger = logging.getLogger(__name__)
+        self.session = None
+    
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """获取 HTTP 会话"""
+        if self.session is None:
+            self.session = aiohttp.ClientSession(headers=self.headers)
+        return self.session
+    
+    async def close(self) -> None:
+        """关闭会话"""
+        if self.session:
+            await self.session.close()
+    
+    async def get_space_status(self, space_id: str) -> SpaceStatus:
+        """获取 Space 状态"""
+        try:
+            session = await self._get_session()
+            url = f"{self.base_url}/spaces/{space_id}"
+            
+            async with session.get(url) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    runtime_data = data.get('runtime', {})
+                    
+                    # 根据运行时状态确定 Space 状态
+                    if runtime_data.get('stage') == 'BUILDING':
+                        return SpaceStatus.BUILDING
+                    elif runtime_data.get('stage') == 'RUNNING':
+                        if runtime_data.get('state') == 'RUNNING':
+                            return SpaceStatus.RUNNING
+                        else:
+                            return SpaceStatus.ERROR
+                    elif runtime_data.get('stage') == 'STOPPED':
+                        return SpaceStatus.STOPPED
+                    else:
+                        return SpaceStatus.ERROR
+                else:
+                    self.logger.error(f"获取 Space 状态失败: {response.status}")
+                    return SpaceStatus.UNKNOWN
+                    
+        except Exception as e:
+            self.logger.error(f"获取 Space {space_id} 状态异常: {e}")
+            return SpaceStatus.UNKNOWN
+    
+    async def get_space_logs(self, space_id: str, lines: int = 100) -> str:
+        """获取 Space 日志"""
+        try:
+            session = await self._get_session()
+            url = f"{self.base_url}/spaces/{space_id}/logs"
+            params = {"lines": lines}
+            
+            async with session.get(url, params=params) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    # 解析日志数据
+                    log_lines = []
+                    for entry in data:
+                        if isinstance(entry, dict) and 'message' in entry:
+                            log_lines.append(entry['message'])
+                        elif isinstance(entry, str):
+                            log_lines.append(entry)
+                    
+                    return '\n'.join(log_lines)
+                else:
+                    error_msg = await response.text()
+                    self.logger.error(f"获取日志失败: {response.status} - {error_msg}")
+                    return f"ERROR: 无法获取日志 - {response.status}"
+                    
+        except Exception as e:
+            self.logger.error(f"获取 Space {space_id} 日志异常: {e}")
+            return f"ERROR: 获取日志异常 - {str(e)}"
+    
+    async def trigger_rebuild(self, space_id: str) -> bool:
+        """触发重新构建"""
+        try:
+            session = await self._get_session()
+            url = f"{self.base_url}/spaces/{space_id}/restart"
+            
+            async with session.post(url) as response:
+                if response.status == 200:
+                    self.logger.info(f"成功触发 Space {space_id} 重新构建")
+                    return True
+                else:
+                    error_msg = await response.text()
+                    self.logger.error(f"触发重新构建失败: {response.status} - {error_msg}")
+                    return False
+                    
+        except Exception as e:
+            self.logger.error(f"触发重新构建异常: {e}")
+            return False
+    
+    async def get_space_info(self, space_id: str) -> SpaceInfo:
+        """获取 Space 详细信息"""
+        try:
+            session = await self._get_session()
+            url = f"{self.base_url}/spaces/{space_id}"
+            
+            async with session.get(url) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    
+                    return SpaceInfo(
+                        space_id=space_id,
+                        name=data.get('id', space_id),
+                        repository_url=data.get('url', ''),
+                        current_status=await self.get_space_status(space_id),
+                        last_updated=datetime.now(),
+                        dockerfile_path="Dockerfile",  # 默认路径
+                        local_path=""  # 本地路径需要额外配置
+                    )
+                else:
+                    raise Exception(f"无法获取 Space 信息: {response.status}")
+                    
+        except Exception as e:
+            self.logger.error(f"获取 Space {space_id} 信息异常: {e}")
+            # 返回默认信息
+            return SpaceInfo(
+                space_id=space_id,
+                name=space_id,
+                repository_url="",
+                current_status=SpaceStatus.UNKNOWN,
+                last_updated=datetime.now()
+            )
+    
+    async def get_space_discussion(self, space_id: str) -> List[Dict]:
+        """获取 Space 讨论信息（用于获取更多上下文）"""
+        try:
+            session = await self._get_session()
+            url = f"{self.base_url}/spaces/{space_id}/discussions"
+            
+            async with session.get(url) as response:
+                if response.status == 200:
+                    return await response.json()
+                else:
+                    return []
+                    
+        except Exception as e:
+            self.logger.error(f"获取 Space {space_id} 讨论信息异常: {e}")
+            return []
+    
+    async def get_space_runtime_info(self, space_id: str) -> Dict[str, Any]:
+        """获取 Space 运行时详细信息"""
+        try:
+            session = await self._get_session()
+            url = f"{self.base_url}/spaces/{space_id}/runtime"
+            
+            async with session.get(url) as response:
+                if response.status == 200:
+                    return await response.json()
+                else:
+                    return {}
+                    
+        except Exception as e:
+            self.logger.error(f"获取 Space {space_id} 运行时信息异常: {e}")
+            return {}
+
+class HuggingFaceWebhookHandler:
+    """HuggingFace Webhook 处理器"""
+    
+    def __init__(self, api_client: HuggingFaceAPIClient):
+        self.api_client = api_client
+        self.logger = logging.getLogger(__name__)
+        self.event_handlers = {
+            'space.status_updated': self._handle_status_update,
+            'space.build_error': self._handle_build_error,
+            'space.started': self._handle_space_started,
+            'space.stopped': self._handle_space_stopped
+        }
+    
+    async def handle_webhook(self, payload: Dict[str, Any]) -> None:
+        """处理 Webhook 事件"""
+        try:
+            event_type = payload.get('event')
+            if event_type in self.event_handlers:
+                await self.event_handlers[event_type](payload)
+            else:
+                self.logger.warning(f"未知的事件类型: {event_type}")
+                
+        except Exception as e:
+            self.logger.error(f"处理 Webhook 事件失败: {e}")
+    
+    async def _handle_status_update(self, payload: Dict[str, Any]) -> None:
+        """处理状态更新事件"""
+        space_id = payload.get('space', {}).get('id')
+        new_status = payload.get('space', {}).get('runtime', {}).get('stage')
+        
+        self.logger.info(f"Space {space_id} 状态更新为: {new_status}")
+        
+        # 根据状态变化触发相应处理
+        if new_status == 'ERROR':
+            await self._handle_build_error(payload)
+    
+    async def _handle_build_error(self, payload: Dict[str, Any]) -> None:
+        """处理构建错误事件"""
+        space_id = payload.get('space', {}).get('id')
+        
+        # 获取错误日志
+        logs = await self.api_client.get_space_logs(space_id, lines=50)
+        
+        # 触发错误分析流程
+        # 这里需要与错误分析器集成
+        
+    async def _handle_space_started(self, payload: Dict[str, Any]) -> None:
+        """处理 Space 启动事件"""
+        space_id = payload.get('space', {}).get('id')
+        self.logger.info(f"Space {space_id} 启动成功")
+    
+    async def _handle_space_stopped(self, payload: Dict[str, Any]) -> None:
+        """处理 Space 停止事件"""
+        space_id = payload.get('space', {}).get('id')
+        self.logger.info(f"Space {space_id} 已停止")
+
+class RateLimiter:
+    """API 请求限制器"""
+    
+    def __init__(self, max_requests_per_minute: int = 60):
+        self.max_requests = max_requests_per_minute
+        self.requests = []
+        self.lock = asyncio.Lock()
+    
+    async def acquire(self) -> None:
+        """获取请求许可"""
+        async with self.lock:
+            now = datetime.now()
+            # 清理超过1分钟的请求记录
+            self.requests = [req_time for req_time in self.requests 
+                           if (now - req_time).total_seconds() < 60]
+            
+            # 检查是否超过限制
+            if len(self.requests) >= self.max_requests:
+                # 计算需要等待的时间
+                oldest_request = min(self.requests)
+                wait_time = 60 - (now - oldest_request).total_seconds()
+                if wait_time > 0:
+                    await asyncio.sleep(wait_time)
+            
+            # 记录当前请求
+            self.requests.append(now)
+
+class HuggingFaceAPIClientWithRateLimit(HuggingFaceAPIClient):
+    """带速率限制的 HuggingFace API 客户端"""
+    
+    def __init__(self, token: str, rate_limit: int = 60):
+        super().__init__(token)
+        self.rate_limiter = RateLimiter(rate_limit)
+        self.base_client = HuggingFaceAPIClient(token)
+    
+    async def get_space_status(self, space_id: str) -> SpaceStatus:
+        """获取 Space 状态（带速率限制）"""
+        await self.rate_limiter.acquire()
+        return await self.base_client.get_space_status(space_id)
+    
+    async def get_space_logs(self, space_id: str, lines: int = 100) -> str:
+        """获取 Space 日志（带速率限制）"""
+        await self.rate_limiter.acquire()
+        return await self.base_client.get_space_logs(space_id, lines)
+    
+    async def trigger_rebuild(self, space_id: str) -> bool:
+        """触发重新构建（带速率限制）"""
+        await self.rate_limiter.acquire()
+        return await self.base_client.trigger_rebuild(space_id)
+    
+    async def get_space_info(self, space_id: str) -> SpaceInfo:
+        """获取 Space 详细信息（带速率限制）"""
+        await self.rate_limiter.acquire()
+        return await self.base_client.get_space_info(space_id)

usage_examples.py

@@ -0,0 +1,457 @@
+"""
+使用示例和最佳实践
+展示系统的基本使用流程和高级功能
+"""
+
+import asyncio
+import logging
+from datetime import datetime
+from typing import List, Dict, Any
+
+from core_system import AutoRepairSystem, SpaceStatus, ErrorType
+from huggingface_client import HuggingFaceAPIClient
+from error_analyzer import IntelligentErrorAnalyzer
+
+# ============================================================================
+# 基本使用示例
+# ============================================================================
+
+async def basic_usage_example():
+    """基本使用示例"""
+    
+    # 1. 初始化系统
+    system = AutoRepairSystem("config.json")
+    
+    # 2. 配置要监控的 Spaces
+    space_ids = [
+        "your-username/space-1",
+        "your-username/space-2", 
+        "your-username/space-3"
+    ]
+    
+    print(f"开始监控 {len(space_ids)} 个 Space...")
+    
+    try:
+        # 3. 启动系统
+        await system.start(space_ids)
+    except KeyboardInterrupt:
+        print("\n停止监控...")
+        system.monitor.stop()
+
+# ============================================================================
+# 高级使用示例
+# ============================================================================
+
+class AdvancedUsageExample:
+    """高级使用示例类"""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+    
+    async def custom_monitoring_workflow(self, space_ids: List[str]) -> None:
+        """自定义监控工作流"""
+        
+        # 初始化各个组件
+        hf_client = HuggingFaceAPIClient("your_token_here")
+        error_analyzer = IntelligentErrorAnalyzer()
+        
+        for space_id in space_ids:
+            # 1. 检查状态
+            status = await hf_client.get_space_status(space_id)
+            print(f"Space {space_id}: {status.value}")
+            
+            # 2. 如果有错误，分析日志
+            if status == SpaceStatus.ERROR:
+                logs = await hf_client.get_space_logs(space_id, lines=100)
+                errors = await error_analyzer.analyze_logs(logs)
+                
+                # 3. 分类并处理错误
+                for error in errors:
+                    if error.confidence > 0.8:
+                        await self._handle_high_confidence_error(space_id, error)
+                    else:
+                        await self._handle_low_confidence_error(space_id, error)
+    
+    async def _handle_high_confidence_error(self, space_id: str, error) -> None:
+        """处理高置信度错误"""
+        print(f"高置信度错误 {space_id}: {error.error_type.value}")
+        
+        if error.error_type == ErrorType.DEPENDENCY_INSTALL:
+            await self._fix_dependency_error(space_id, error)
+        elif error.error_type == ErrorType.DOCKERFILE_SYNTAX:
+            await self._fix_dockerfile_error(space_id, error)
+        # ... 其他错误类型处理
+    
+    async def _fix_dependency_error(self, space_id: str, error) -> None:
+        """修复依赖错误"""
+        print(f"修复 {space_id} 的依赖错误...")
+        
+        # 实现具体的修复逻辑
+        # 1. 分析依赖类型（Python/Node.js）
+        # 2. 尝试更换源地址
+        # 3. 调整版本号
+        # 4. 重新安装依赖
+    
+    async def _fix_dockerfile_error(self, space_id: str, error) -> None:
+        """修复 Dockerfile 错误"""
+        print(f"修复 {space_id} 的 Dockerfile 错误...")
+        
+        # 实现具体的修复逻辑
+        # 1. 定位错误行
+        # 2. 语法修正
+        # 3. 优化命令结构
+
+# ============================================================================
+# 批量处理示例
+# ============================================================================
+
+class BatchProcessingExample:
+    """批量处理示例"""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+    
+    async def batch_monitor_spaces(self, space_configs: List[Dict[str, Any]]) -> None:
+        """批量监控 Spaces"""
+        
+        tasks = []
+        for config in space_configs:
+            task = self._monitor_single_space(config)
+            tasks.append(task)
+        
+        await asyncio.gather(*tasks, return_exceptions=True)
+    
+    async def _monitor_single_space(self, config: Dict[str, Any]) -> None:
+        """监控单个 Space"""
+        space_id = config['space_id']
+        monitoring_interval = config.get('interval', 60)
+        max_retries = config.get('max_retries', 3)
+        
+        retry_count = 0
+        while retry_count < max_retries:
+            try:
+                # 监控逻辑
+                status = await self._check_space_status(space_id)
+                
+                if status != SpaceStatus.ERROR:
+                    break
+                
+                retry_count += 1
+                if retry_count < max_retries:
+                    await asyncio.sleep(monitoring_interval)
+                    
+            except Exception as e:
+                self.logger.error(f"监控 {space_id} 失败: {e}")
+                break
+    
+    async def _check_space_status(self, space_id: str) -> SpaceStatus:
+        """检查 Space 状态"""
+        # 实现状态检查逻辑
+        pass
+
+# ============================================================================
+# 自定义错误分析示例
+# ============================================================================
+
+class CustomErrorAnalyzer:
+    """自定义错误分析器"""
+    
+    def __init__(self):
+        self.custom_patterns = self._load_custom_patterns()
+    
+    async def analyze_with_custom_rules(self, logs: str) -> List[Dict]:
+        """使用自定义规则分析"""
+        
+        results = []
+        
+        # 1. 应用自定义模式
+        for pattern in self.custom_patterns:
+            matches = pattern['regex'].findall(logs)
+            if matches:
+                results.append({
+                    'type': pattern['type'],
+                    'matches': matches,
+                    'severity': pattern['severity'],
+                    'suggested_fix': pattern['fix']
+                })
+        
+        # 2. 应用机器学习模型（如果可用）
+        ml_results = await self._ml_analysis(logs)
+        results.extend(ml_results)
+        
+        # 3. 综合评分
+        scored_results = self._score_results(results)
+        
+        return scored_results
+    
+    def _load_custom_patterns(self) -> List[Dict]:
+        """加载自定义错误模式"""
+        return [
+            {
+                'name': 'Custom GPU Error',
+                'regex': re.compile(r'GPU.*out of memory|CUDA.*error'),
+                'type': 'gpu_error',
+                'severity': 'high',
+                'fix': '减少批处理大小或使用更小的模型'
+            },
+            {
+                'name': 'Custom Timeout Pattern',
+                'regex': re.compile(r'operation.*timeout.*after.*(\d+)ms'),
+                'type': 'custom_timeout',
+                'severity': 'medium',
+                'fix': '增加超时设置或优化性能'
+            }
+        ]
+    
+    async def _ml_analysis(self, logs: str) -> List[Dict]:
+        """机器学习分析"""
+        # 这里可以集成预训练的错误分类模型
+        return []
+    
+    def _score_results(self, results: List[Dict]) -> List[Dict]:
+        """对结果进行评分"""
+        for result in results:
+            if result['severity'] == 'high':
+                result['score'] = 0.9
+            elif result['severity'] == 'medium':
+                result['score'] = 0.7
+            else:
+                result['score'] = 0.5
+        
+        return sorted(results, key=lambda x: x['score'], reverse=True)
+
+# ============================================================================
+# Webhook 集成示例
+# ============================================================================
+
+class WebhookIntegrationExample:
+    """Webhook 集成示例"""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+    
+    async def setup_webhook_server(self) -> None:
+        """设置 Webhook 服务器"""
+        
+        from fastapi import FastAPI, Request
+        import uvicorn
+        
+        app = FastAPI()
+        
+        @app.post("/webhook/huggingface")
+        async def handle_hf_webhook(request: Request):
+            payload = await request.json()
+            
+            # 处理不同的事件类型
+            event_type = payload.get('event')
+            
+            if event_type == 'space.status_updated':
+                await self._handle_status_update(payload)
+            elif event_type == 'space.build_error':
+                await self._handle_build_error(payload)
+            elif event_type == 'space.started':
+                await self._handle_space_started(payload)
+            
+            return {"status": "ok"}
+        
+        # 启动服务器
+        config = uvicorn.Config(app, host="0.0.0.0", port=8000)
+        server = uvicorn.Server(config)
+        await server.serve()
+    
+    async def _handle_status_update(self, payload: Dict) -> None:
+        """处理状态更新事件"""
+        space_id = payload.get('space', {}).get('id')
+        new_status = payload.get('space', {}).get('runtime', {}).get('stage')
+        
+        self.logger.info(f"Space {space_id} 状态更新: {new_status}")
+        
+        # 触发相应处理逻辑
+        if new_status == 'ERROR':
+            await self._trigger_repair_workflow(space_id)
+    
+    async def _trigger_repair_workflow(self, space_id: str) -> None:
+        """触发修复工作流"""
+        # 实现修复工作流
+        pass
+
+# ============================================================================
+# 测试和调试示例
+# ============================================================================
+
+class TestingExample:
+    """测试和��试示例"""
+    
+    def __init__(self):
+        self.logger = logging.getLogger(__name__)
+    
+    async def test_error_analysis(self) -> None:
+        """测试错误分析功能"""
+        
+        # 模拟日志数据
+        sample_logs = """
+        ERROR: Could not find a version that satisfies the requirement torch==2.0.0
+        ERROR: No matching distribution found for torch==2.0.0
+        Build failed
+        """
+        
+        analyzer = IntelligentErrorAnalyzer()
+        errors = await analyzer.analyze_logs(sample_logs)
+        
+        print(f"检测到 {len(errors)} 个错误:")
+        for error in errors:
+            print(f"- {error.error_type.value}: {error.message}")
+            print(f"  置信度: {error.confidence}")
+    
+    async def test_repair_strategies(self) -> None:
+        """测试修复策略"""
+        
+        # 测试不同错误类型的修复策略
+        from core_system import SmartRepairEngine, ErrorInfo, SpaceInfo
+        
+        repair_engine = SmartRepairEngine()
+        
+        test_errors = [
+            ErrorInfo(
+                error_type=ErrorType.DEPENDENCY_INSTALL,
+                message="pip install failed",
+                log_snippet="ERROR: Could not find torch",
+                confidence=0.9
+            ),
+            ErrorInfo(
+                error_type=ErrorType.DOCKERFILE_SYNTAX,
+                message="Dockerfile syntax error",
+                log_snippet="failed to solve: syntax error",
+                confidence=0.85
+            )
+        ]
+        
+        space_info = SpaceInfo(
+            space_id="test/space",
+            name="Test Space",
+            repository_url="",
+            current_status=SpaceStatus.ERROR,
+            last_updated=datetime.now()
+        )
+        
+        for error in test_errors:
+            strategy = await repair_engine.generate_strategy(error, space_info)
+            if strategy:
+                print(f"修复策略: {strategy.action.value}")
+                print(f"描述: {strategy.description}")
+                print(f"成功率: {strategy.success_rate}")
+                print(f"风险等级: {strategy.risk_level}")
+                print()
+
+# ============================================================================
+# 性能监控示例
+# ============================================================================
+
+class PerformanceMonitoringExample:
+    """性能监控示例"""
+    
+    def __init__(self):
+        self.metrics = {}
+    
+    async def monitor_system_performance(self) -> None:
+        """监控系统性能"""
+        
+        while True:
+            # 收集性能指标
+            current_metrics = await self._collect_metrics()
+            
+            # 存储和比较指标
+            self._store_metrics(current_metrics)
+            
+            # 检查异常
+            anomalies = self._detect_anomalies(current_metrics)
+            
+            if anomalies:
+                await self._handle_anomalies(anomalies)
+            
+            await asyncio.sleep(60)  # 每分钟检查一次
+    
+    async def _collect_metrics(self) -> Dict[str, Any]:
+        """收集性能指标"""
+        return {
+            'timestamp': datetime.now(),
+            'cpu_usage': self._get_cpu_usage(),
+            'memory_usage': self._get_memory_usage(),
+            'active_repairs': self._get_active_repairs(),
+            'queue_size': self._get_queue_size(),
+            'error_rate': self._get_error_rate()
+        }
+    
+    def _store_metrics(self, metrics: Dict[str, Any]) -> None:
+        """存储指标"""
+        # 存储到数据库或时间序列数据库
+        pass
+    
+    def _detect_anomalies(self, metrics: Dict[str, Any]) -> List[str]:
+        """检测异常"""
+        anomalies = []
+        
+        if metrics['cpu_usage'] > 80:
+            anomalies.append(f"CPU 使用率过高: {metrics['cpu_usage']}%")
+        
+        if metrics['memory_usage'] > 90:
+            anomalies.append(f"内存使用率过高: {metrics['memory_usage']}%")
+        
+        if metrics['error_rate'] > 0.1:
+            anomalies.append(f"错误率过高: {metrics['error_rate']}")
+        
+        return anomalies
+    
+    async def _handle_anomalies(self, anomalies: List[str]) -> None:
+        """处理异常"""
+        for anomaly in anomalies:
+            self.logger.warning(f"性能异常: {anomaly}")
+            # 发送告警或自动调整
+
+# ============================================================================
+# 主程序示例
+# ============================================================================
+
+async def main():
+    """主程序示例"""
+    print("HuggingFace Spaces 自动修复系统示例")
+    print("=" * 50)
+    
+    # 选择运行的示例
+    examples = {
+        "1": ("基本使用", basic_usage_example),
+        "2": ("高级使用", lambda: AdvancedUsageExample().custom_monitoring_workflow(
+            ["user/space1", "user/space2"]
+        )),
+        "3": ("测试错误分析", lambda: TestingExample().test_error_analysis()),
+        "4": ("性能监控", lambda: PerformanceMonitoringExample().monitor_system_performance()),
+        "5": ("Webhook 服务器", lambda: WebhookIntegrationExample().setup_webhook_server())
+    }
+    
+    print("请选择要运行的示例:")
+    for key, (desc, _) in examples.items():
+        print(f"{key}. {desc}")
+    
+    choice = input("请输入选择 (1-5): ").strip()
+    
+    if choice in examples:
+        desc, func = examples[choice]
+        print(f"\n运行: {desc}")
+        try:
+            await func()
+        except KeyboardInterrupt:
+            print("\n程序被用户中断")
+        except Exception as e:
+            print(f"运行出错: {e}")
+    else:
+        print("无效的选择")
+
+if __name__ == "__main__":
+    # 设置日志
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    # 运行主程序
+    asyncio.run(main())