code-abyss 1.5.1

package/skills/development/java.md

@@ -0,0 +1,277 @@
+---
+name: java
+description: Java 开发。企业级应用、Spring Boot、微服务。当用户提到 Java、Spring、Maven、Gradle、JVM 时使用。
+---
+
+# 📜 符箓秘典 · Java
+
+
+## Spring Boot
+
+### 基础项目
+```java
+@SpringBootApplication
+public class Application {
+    public static void main(String[] args) {
+        SpringApplication.run(Application.class, args);
+    }
+}
+
+// Controller
+@RestController
+@RequestMapping("/api/users")
+public class UserController {
+
+    @Autowired
+    private UserService userService;
+
+    @GetMapping("/{id}")
+    public ResponseEntity<User> getUser(@PathVariable Long id) {
+        return userService.findById(id)
+            .map(ResponseEntity::ok)
+            .orElse(ResponseEntity.notFound().build());
+    }
+
+    @PostMapping
+    public ResponseEntity<User> createUser(@Valid @RequestBody UserDTO dto) {
+        User user = userService.create(dto);
+        return ResponseEntity.status(HttpStatus.CREATED).body(user);
+    }
+}
+
+// Service
+@Service
+public class UserService {
+
+    @Autowired
+    private UserRepository userRepository;
+
+    public Optional<User> findById(Long id) {
+        return userRepository.findById(id);
+    }
+
+    @Transactional
+    public User create(UserDTO dto) {
+        User user = new User();
+        user.setName(dto.getName());
+        user.setEmail(dto.getEmail());
+        return userRepository.save(user);
+    }
+}
+
+// Repository
+@Repository
+public interface UserRepository extends JpaRepository<User, Long> {
+    Optional<User> findByEmail(String email);
+    List<User> findByNameContaining(String name);
+}
+```
+
+### Entity
+```java
+@Entity
+@Table(name = "users")
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class User {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(nullable = false)
+    private String name;
+
+    @Column(unique = true, nullable = false)
+    private String email;
+
+    @CreatedDate
+    private LocalDateTime createdAt;
+
+    @LastModifiedDate
+    private LocalDateTime updatedAt;
+}
+
+// DTO
+@Data
+public class UserDTO {
+    @NotBlank(message = "Name is required")
+    private String name;
+
+    @Email(message = "Invalid email")
+    @NotBlank(message = "Email is required")
+    private String email;
+}
+```
+
+### 配置
+```yaml
+# application.yml
+spring:
+  datasource:
+    url: jdbc:postgresql://localhost:5432/mydb
+    username: ${DB_USER}
+    password: ${DB_PASS}
+  jpa:
+    hibernate:
+      ddl-auto: update
+    show-sql: true
+
+server:
+  port: 8080
+
+logging:
+  level:
+    root: INFO
+    com.myapp: DEBUG
+```
+
+## 异常处理
+
+```java
+@RestControllerAdvice
+public class GlobalExceptionHandler {
+
+    @ExceptionHandler(ResourceNotFoundException.class)
+    public ResponseEntity<ErrorResponse> handleNotFound(ResourceNotFoundException ex) {
+        ErrorResponse error = new ErrorResponse(
+            HttpStatus.NOT_FOUND.value(),
+            ex.getMessage()
+        );
+        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(error);
+    }
+
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<ErrorResponse> handleValidation(MethodArgumentNotValidException ex) {
+        String message = ex.getBindingResult().getFieldErrors().stream()
+            .map(FieldError::getDefaultMessage)
+            .collect(Collectors.joining(", "));
+        ErrorResponse error = new ErrorResponse(
+            HttpStatus.BAD_REQUEST.value(),
+            message
+        );
+        return ResponseEntity.badRequest().body(error);
+    }
+}
+
+// 自定义异常
+public class ResourceNotFoundException extends RuntimeException {
+    public ResourceNotFoundException(String message) {
+        super(message);
+    }
+}
+```
+
+## 测试
+
+```java
+@SpringBootTest
+@AutoConfigureMockMvc
+class UserControllerTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+
+    @MockBean
+    private UserService userService;
+
+    @Test
+    void shouldGetUser() throws Exception {
+        User user = new User(1L, "Alice", "alice@example.com");
+        when(userService.findById(1L)).thenReturn(Optional.of(user));
+
+        mockMvc.perform(get("/api/users/1"))
+            .andExpect(status().isOk())
+            .andExpect(jsonPath("$.name").value("Alice"));
+    }
+
+    @Test
+    void shouldCreateUser() throws Exception {
+        UserDTO dto = new UserDTO();
+        dto.setName("Bob");
+        dto.setEmail("bob@example.com");
+
+        User user = new User(1L, "Bob", "bob@example.com");
+        when(userService.create(any())).thenReturn(user);
+
+        mockMvc.perform(post("/api/users")
+                .contentType(MediaType.APPLICATION_JSON)
+                .content(objectMapper.writeValueAsString(dto)))
+            .andExpect(status().isCreated())
+            .andExpect(jsonPath("$.name").value("Bob"));
+    }
+}
+
+// 单元测试
+@ExtendWith(MockitoExtension.class)
+class UserServiceTest {
+
+    @Mock
+    private UserRepository userRepository;
+
+    @InjectMocks
+    private UserService userService;
+
+    @Test
+    void shouldFindById() {
+        User user = new User(1L, "Alice", "alice@example.com");
+        when(userRepository.findById(1L)).thenReturn(Optional.of(user));
+
+        Optional<User> result = userService.findById(1L);
+
+        assertTrue(result.isPresent());
+        assertEquals("Alice", result.get().getName());
+    }
+}
+```
+
+## 项目结构
+
+```
+myproject/
+├── pom.xml / build.gradle
+├── src/
+│   ├── main/
+│   │   ├── java/
+│   │   │   └── com/myapp/
+│   │   │       ├── Application.java
+│   │   │       ├── controller/
+│   │   │       ├── service/
+│   │   │       ├── repository/
+│   │   │       ├── model/
+│   │   │       ├── dto/
+│   │   │       └── config/
+│   │   └── resources/
+│   │       └── application.yml
+│   └── test/
+│       └── java/
+└── target/
+```
+
+## 常用依赖
+
+```xml
+<!-- pom.xml -->
+<dependencies>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-web</artifactId>
+    </dependency>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-data-jpa</artifactId>
+    </dependency>
+    <dependency>
+        <groupId>org.springframework.boot</groupId>
+        <artifactId>spring-boot-starter-validation</artifactId>
+    </dependency>
+    <dependency>
+        <groupId>org.projectlombok</groupId>
+        <artifactId>lombok</artifactId>
+    </dependency>
+</dependencies>
+```
+
+---
+

package/skills/development/python.md

@@ -0,0 +1,288 @@
+---
+name: python
+description: Python 开发。Web框架、数据处理、自动化脚本、测试。当用户提到 Python、Django、Flask、FastAPI、pytest、pandas 时使用。
+---
+
+# 📜 符箓秘典 · Python
+
+
+## Web 框架
+
+### FastAPI (推荐)
+```python
+from fastapi import FastAPI, HTTPException, Depends
+from pydantic import BaseModel
+from typing import Optional
+
+app = FastAPI()
+
+class User(BaseModel):
+    name: str
+    email: str
+    age: Optional[int] = None
+
+@app.get("/users/{user_id}")
+async def get_user(user_id: int):
+    return {"user_id": user_id}
+
+@app.post("/users")
+async def create_user(user: User):
+    return user
+
+# 依赖注入
+async def get_db():
+    db = Database()
+    try:
+        yield db
+    finally:
+        await db.close()
+
+@app.get("/items")
+async def get_items(db = Depends(get_db)):
+    return await db.fetch_all("SELECT * FROM items")
+```
+
+### Flask
+```python
+from flask import Flask, request, jsonify
+
+app = Flask(__name__)
+
+@app.route('/api/users', methods=['GET', 'POST'])
+def users():
+    if request.method == 'POST':
+        data = request.json
+        return jsonify(data), 201
+    return jsonify([])
+
+@app.errorhandler(404)
+def not_found(e):
+    return jsonify(error="Not found"), 404
+```
+
+### Django
+```python
+# models.py
+from django.db import models
+
+class User(models.Model):
+    name = models.CharField(max_length=100)
+    email = models.EmailField(unique=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+# views.py
+from django.http import JsonResponse
+from django.views import View
+
+class UserView(View):
+    def get(self, request, user_id):
+        user = User.objects.get(id=user_id)
+        return JsonResponse({'name': user.name})
+
+# urls.py
+urlpatterns = [
+    path('users/<int:user_id>/', UserView.as_view()),
+]
+```
+
+## 异步编程
+
+```python
+import asyncio
+import aiohttp
+
+async def fetch(url: str) -> str:
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            return await response.text()
+
+async def fetch_all(urls: list[str]) -> list[str]:
+    tasks = [fetch(url) for url in urls]
+    return await asyncio.gather(*tasks)
+
+# 运行
+asyncio.run(fetch_all(['http://example.com', 'http://example.org']))
+```
+
+## 数据处理
+
+### Pandas
+```python
+import pandas as pd
+
+# 读取数据
+df = pd.read_csv('data.csv')
+df = pd.read_json('data.json')
+
+# 数据清洗
+df = df.dropna()
+df = df.drop_duplicates()
+df['column'] = df['column'].str.strip()
+
+# 数据转换
+df['date'] = pd.to_datetime(df['date'])
+df['category'] = df['category'].astype('category')
+
+# 聚合分析
+result = df.groupby('category').agg({
+    'value': ['sum', 'mean', 'count']
+})
+
+# 导出
+df.to_csv('output.csv', index=False)
+df.to_json('output.json', orient='records')
+```
+
+## 测试
+
+### pytest
+```python
+import pytest
+from myapp import calculate, UserService
+
+# 基础测试
+def test_add():
+    assert calculate.add(1, 2) == 3
+
+# 参数化
+@pytest.mark.parametrize("a,b,expected", [
+    (1, 2, 3),
+    (0, 0, 0),
+    (-1, 1, 0),
+])
+def test_add_params(a, b, expected):
+    assert calculate.add(a, b) == expected
+
+# Fixture
+@pytest.fixture
+def user_service():
+    service = UserService()
+    yield service
+    service.cleanup()
+
+def test_create_user(user_service):
+    user = user_service.create("test")
+    assert user.name == "test"
+
+# Mock
+from unittest.mock import Mock, patch
+
+@patch('myapp.requests.get')
+def test_fetch(mock_get):
+    mock_get.return_value.json.return_value = {"id": 1}
+    result = fetch_user(1)
+    assert result["id"] == 1
+
+# 异步测试
+@pytest.mark.asyncio
+async def test_async_fetch():
+    result = await async_fetch()
+    assert result is not None
+```
+
+### 运行测试
+```bash
+pytest                      # 运行所有
+pytest test_file.py         # 指定文件
+pytest -k "test_add"        # 匹配名称
+pytest -v                   # 详细输出
+pytest --cov=myapp          # 覆盖率
+pytest -x                   # 失败即停
+```
+
+## CLI 工具
+
+### Typer (推荐)
+```python
+import typer
+
+app = typer.Typer()
+
+@app.command()
+def hello(name: str, count: int = 1):
+    """Say hello NAME, COUNT times."""
+    for _ in range(count):
+        typer.echo(f"Hello {name}!")
+
+@app.command()
+def goodbye(name: str, formal: bool = False):
+    if formal:
+        typer.echo(f"Goodbye Ms. {name}. Have a good day.")
+    else:
+        typer.echo(f"Bye {name}!")
+
+if __name__ == "__main__":
+    app()
+```
+
+### argparse
+```python
+import argparse
+
+parser = argparse.ArgumentParser(description='My CLI tool')
+parser.add_argument('input', help='Input file')
+parser.add_argument('-o', '--output', default='output.txt')
+parser.add_argument('-v', '--verbose', action='store_true')
+
+args = parser.parse_args()
+```
+
+## 项目结构
+
+```
+myproject/
+├── pyproject.toml          # 项目配置
+├── README.md
+├── src/
+│   └── myproject/
+│       ├── __init__.py
+│       ├── main.py
+│       ├── models.py
+│       └── utils.py
+├── tests/
+│   ├── __init__.py
+│   ├── conftest.py
+│   └── test_main.py
+└── scripts/
+    └── run.py
+```
+
+### pyproject.toml
+```toml
+[project]
+name = "myproject"
+version = "0.1.0"
+dependencies = [
+    "fastapi>=0.100.0",
+    "uvicorn>=0.23.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 120
+select = ["E", "F", "I"]
+```
+
+## 常用库
+
+| 库 | 用途 |
+|---|------|
+| requests/httpx | HTTP 客户端 |
+| aiohttp | 异步 HTTP |
+| SQLAlchemy | ORM |
+| Pydantic | 数据验证 |
+| Click/Typer | CLI |
+| pytest | 测试 |
+| pandas | 数据处理 |
+| loguru | 日志 |
+
+---
+