feat(desktop): ✨ 实现一些功能

1. 实现任务暂停功能

2. 实现页面的国际化功能

3.优化项目的结构以及BUG

4. 优化系统架构

5. 实现一大堆的功能

.trae/skills/debugging/scripts/parse-logs.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Error log parser for debugging skill.
+Extracts errors, exceptions, and stack traces from log files.
+"""
+
+import json
+import re
+import sys
+from pathlib import Path
+
+
+def extract_errors(log_content: str) -> list[dict]:
+    """Extract errors and exceptions from log content."""
+    errors = []
+
+    patterns = {
+        "error": re.compile(r"(?i)(error|ERROR):\s*(.+?)(?:\n|$)"),
+        "exception": re.compile(r"(?i)(exception|Exception|EXCEPTION):\s*(.+?)(?:\n|$)"),
+        "fatal": re.compile(r"(?i)(fatal|FATAL):\s*(.+?)(?:\n|$)"),
+        "critical": re.compile(r"(?i)(critical|CRITICAL):\s*(.+?)(?:\n|$)"),
+        "traceback": re.compile(r"Traceback \(most recent call last\):(.+?)(?=\n\w|\Z)", re.DOTALL),
+    }
+
+    lines = log_content.split("\n")
+    for i, line in enumerate(lines):
+        for error_type, pattern in patterns.items():
+            match = pattern.search(line)
+            if match:
+                error = {
+                    "type": error_type,
+                    "message": (match.group(2) if len(match.groups()) > 1 else match.group(0)),
+                    "line_number": i + 1,
+                    "line_content": line,
+                    "timestamp": extract_timestamp(line),
+                }
+
+                if error_type == "traceback":
+                    error["stack_trace"] = match.group(1).strip()
+
+                errors.append(error)
+
+    return errors
+
+
+def extract_timestamp(line: str) -> str | None:
+    """Extract timestamp from log line if present."""
+    timestamp_patterns = [
+        r"(\d{4}-\d{2}-\d{2}[\sT]\d{2}:\d{2}:\d{2})",
+        r"(\d{2}/\d{2}/\d{4}\s+\d{2}:\d{2}:\d{2})",
+        r"\[(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})\]",
+    ]
+
+    for pattern in timestamp_patterns:
+        match = re.search(pattern, line)
+        if match:
+            return match.group(1)
+
+    return None
+
+
+def group_errors_by_type(errors: list[dict]) -> dict[str, list[dict]]:
+    """Group errors by type."""
+    grouped: dict[str, list[dict]] = {}
+    for error in errors:
+        error_type = error["type"]
+        if error_type not in grouped:
+            grouped[error_type] = []
+        grouped[error_type].append(error)
+    return grouped
+
+
+def analyze_error_patterns(errors: list[dict]) -> dict:
+    """Analyze error patterns and provide insights."""
+    if not errors:
+        return {}
+
+    type_counts: dict[str, int] = {}
+    for error in errors:
+        error_type = error["type"]
+        type_counts[error_type] = type_counts.get(error_type, 0) + 1
+
+    message_counts: dict[str, int] = {}
+    for error in errors:
+        message = error.get("message", "")[:100]
+        message_counts[message] = message_counts.get(message, 0) + 1
+
+    most_common = sorted(message_counts.items(), key=lambda x: x[1], reverse=True)[:5]
+
+    return {
+        "total_errors": len(errors),
+        "by_type": type_counts,
+        "most_common_errors": [{"message": msg, "count": count} for msg, count in most_common],
+    }
+
+
+def main():
+    """Main entry point."""
+    if len(sys.argv) < 2:
+        print("Usage: parse_logs.py <log_file>")
+        sys.exit(1)
+
+    log_file = Path(sys.argv[1])
+    if not log_file.exists():
+        print(f"Error: File not found: {log_file}")
+        sys.exit(1)
+
+    log_content = log_file.read_text()
+
+    errors = extract_errors(log_content)
+
+    analysis = analyze_error_patterns(errors)
+
+    output = {
+        "file": str(log_file),
+        "errors": errors,
+        "analysis": analysis,
+        "grouped_by_type": group_errors_by_type(errors),
+    }
+
+    print(json.dumps(output, indent=2))
+
+
+if __name__ == "__main__":
+    main()