aigroup-workflow 2.1.1 → 2.2.0

package/skills/dotnet-core-expert/references/minimal-apis.md

@@ -1,319 +0,0 @@
-# Minimal APIs
-
-## Basic Endpoint Patterns
-
-```csharp
-using Microsoft.AspNetCore.Mvc;
-
-var builder = WebApplication.CreateBuilder(args);
-
-// Add services
-builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
-
-var app = builder.Build();
-
-// Configure middleware
-if (app.Environment.IsDevelopment())
-{
-    app.UseSwagger();
-    app.UseSwaggerUI();
-}
-
-app.UseHttpsRedirection();
-
-// Simple GET endpoint
-app.MapGet("/api/products", async (IProductService service) =>
-{
-    var products = await service.GetAllAsync();
-    return Results.Ok(products);
-});
-
-// GET with route parameter
-app.MapGet("/api/products/{id:int}", async (int id, IProductService service) =>
-{
-    var product = await service.GetByIdAsync(id);
-    return product is not null
-        ? Results.Ok(product)
-        : Results.NotFound();
-});
-
-// POST with validation
-app.MapPost("/api/products", async (
-    [FromBody] CreateProductRequest request,
-    IProductService service) =>
-{
-    var product = await service.CreateAsync(request);
-    return Results.Created($"/api/products/{product.Id}", product);
-})
-.WithName("CreateProduct")
-.Produces<ProductResponse>(StatusCodes.Status201Created)
-.ProducesValidationProblem();
-
-// PUT endpoint
-app.MapPut("/api/products/{id:int}", async (
-    int id,
-    [FromBody] UpdateProductRequest request,
-    IProductService service) =>
-{
-    var success = await service.UpdateAsync(id, request);
-    return success ? Results.NoContent() : Results.NotFound();
-});
-
-// DELETE endpoint
-app.MapDelete("/api/products/{id:int}", async (int id, IProductService service) =>
-{
-    await service.DeleteAsync(id);
-    return Results.NoContent();
-});
-
-app.Run();
-```
-
-## Route Groups
-
-```csharp
-var app = builder.Build();
-
-var api = app.MapGroup("/api")
-    .WithOpenApi()
-    .RequireAuthorization();
-
-var products = api.MapGroup("/products")
-    .WithTags("Products");
-
-products.MapGet("/", GetAllProducts);
-products.MapGet("/{id:int}", GetProductById);
-products.MapPost("/", CreateProduct);
-products.MapPut("/{id:int}", UpdateProduct);
-products.MapDelete("/{id:int}", DeleteProduct);
-
-static async Task<IResult> GetAllProducts(IProductService service)
-{
-    var products = await service.GetAllAsync();
-    return Results.Ok(products);
-}
-
-static async Task<IResult> GetProductById(int id, IProductService service)
-{
-    var product = await service.GetByIdAsync(id);
-    return product is not null ? Results.Ok(product) : Results.NotFound();
-}
-```
-
-## Filters and Validation
-
-```csharp
-using FluentValidation;
-
-// Request DTO with validation
-public record CreateProductRequest(
-    string Name,
-    string Description,
-    decimal Price,
-    int CategoryId
-);
-
-public class CreateProductValidator : AbstractValidator<CreateProductRequest>
-{
-    public CreateProductValidator()
-    {
-        RuleFor(x => x.Name)
-            .NotEmpty()
-            .MaximumLength(100);
-
-        RuleFor(x => x.Price)
-            .GreaterThan(0)
-            .LessThan(1000000);
-
-        RuleFor(x => x.CategoryId)
-            .GreaterThan(0);
-    }
-}
-
-// Endpoint filter for validation
-public class ValidationFilter<T> : IEndpointFilter where T : class
-{
-    private readonly IValidator<T> _validator;
-
-    public ValidationFilter(IValidator<T> validator)
-    {
-        _validator = validator;
-    }
-
-    public async ValueTask<object?> InvokeAsync(
-        EndpointFilterInvocationContext context,
-        EndpointFilterDelegate next)
-    {
-        var request = context.Arguments.OfType<T>().FirstOrDefault();
-        if (request is null)
-        {
-            return Results.BadRequest("Invalid request");
-        }
-
-        var validationResult = await _validator.ValidateAsync(request);
-        if (!validationResult.IsValid)
-        {
-            return Results.ValidationProblem(
-                validationResult.ToDictionary());
-        }
-
-        return await next(context);
-    }
-}
-
-// Register and use
-builder.Services.AddValidatorsFromAssemblyContaining<Program>();
-
-app.MapPost("/api/products", CreateProduct)
-    .AddEndpointFilter<ValidationFilter<CreateProductRequest>>();
-```
-
-## Dependency Injection
-
-```csharp
-// Service registration
-builder.Services.AddScoped<IProductService, ProductService>();
-builder.Services.AddScoped<IProductRepository, ProductRepository>();
-
-// Multiple parameter binding
-app.MapPost("/api/orders", async (
-    CreateOrderRequest request,
-    IOrderService orderService,
-    IEmailService emailService,
-    ILogger<Program> logger,
-    CancellationToken ct) =>
-{
-    logger.LogInformation("Creating order for {CustomerId}", request.CustomerId);
-
-    var order = await orderService.CreateAsync(request, ct);
-    await emailService.SendOrderConfirmationAsync(order.Id, ct);
-
-    return Results.Created($"/api/orders/{order.Id}", order);
-});
-```
-
-## Response Patterns
-
-```csharp
-// Typed responses
-public record ProductResponse(
-    int Id,
-    string Name,
-    string Description,
-    decimal Price,
-    string CategoryName
-);
-
-// Results.Ok with typed response
-app.MapGet("/api/products/{id:int}", async (int id, IProductService service) =>
-{
-    var product = await service.GetByIdAsync(id);
-    return product is not null
-        ? Results.Ok(product)
-        : Results.NotFound(new { Message = "Product not found" });
-})
-.Produces<ProductResponse>(StatusCodes.Status200OK)
-.Produces(StatusCodes.Status404NotFound);
-
-// Custom result type
-public class PagedResult<T>
-{
-    public required List<T> Items { get; init; }
-    public required int TotalCount { get; init; }
-    public required int Page { get; init; }
-    public required int PageSize { get; init; }
-}
-
-app.MapGet("/api/products", async (
-    [AsParameters] PaginationParams pagination,
-    IProductService service) =>
-{
-    var result = await service.GetPagedAsync(
-        pagination.Page,
-        pagination.PageSize);
-    return Results.Ok(result);
-})
-.Produces<PagedResult<ProductResponse>>();
-
-public record PaginationParams(int Page = 1, int PageSize = 10);
-```
-
-## Error Handling
-
-```csharp
-// Global exception handler
-app.UseExceptionHandler(exceptionHandlerApp =>
-{
-    exceptionHandlerApp.Run(async context =>
-    {
-        var exceptionHandlerFeature =
-            context.Features.Get<IExceptionHandlerFeature>();
-        var exception = exceptionHandlerFeature?.Error;
-
-        var problemDetails = new ProblemDetails
-        {
-            Status = StatusCodes.Status500InternalServerError,
-            Title = "An error occurred",
-            Detail = exception?.Message
-        };
-
-        context.Response.StatusCode = StatusCodes.Status500InternalServerError;
-        await context.Response.WriteAsJsonAsync(problemDetails);
-    });
-});
-
-// Custom endpoint filter for error handling
-public class ErrorHandlingFilter : IEndpointFilter
-{
-    private readonly ILogger<ErrorHandlingFilter> _logger;
-
-    public ErrorHandlingFilter(ILogger<ErrorHandlingFilter> logger)
-    {
-        _logger = logger;
-    }
-
-    public async ValueTask<object?> InvokeAsync(
-        EndpointFilterInvocationContext context,
-        EndpointFilterDelegate next)
-    {
-        try
-        {
-            return await next(context);
-        }
-        catch (ValidationException ex)
-        {
-            _logger.LogWarning(ex, "Validation failed");
-            return Results.ValidationProblem(ex.Errors.ToDictionary(
-                e => e.PropertyName,
-                e => new[] { e.ErrorMessage }
-            ));
-        }
-        catch (NotFoundException ex)
-        {
-            _logger.LogWarning(ex, "Resource not found");
-            return Results.NotFound(new { Message = ex.Message });
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Unhandled exception");
-            return Results.Problem("An unexpected error occurred");
-        }
-    }
-}
-```
-
-## Quick Reference
-
-| Pattern | Usage |
-|---------|-------|
-| `Results.Ok(data)` | 200 with response body |
-| `Results.Created(uri, data)` | 201 with location header |
-| `Results.NoContent()` | 204 no response body |
-| `Results.BadRequest()` | 400 validation error |
-| `Results.NotFound()` | 404 resource not found |
-| `Results.Unauthorized()` | 401 authentication required |
-| `Results.Forbid()` | 403 authorization failed |
-| `app.MapGroup()` | Group related endpoints |
-| `.WithTags()` | OpenAPI tag grouping |
-| `.Produces<T>()` | Document response type |

package/skills/entropy-management/SKILL.md

@@ -1,115 +0,0 @@
----
-name: entropy-management
-description: 定期维护代码库健康度。扫描架构漂移、过期文档、低质量代码，防止技术债积累。应在完成若干任务后或怀疑代码库退化时触发。
----
-
-# 熵管理（Garbage Collection）
-
-## 概述
-
-AI Agent 会复制仓库中已有的模式——包括不好的模式。随着时间推移，这不可避免地导致漂移。
-手动清理不可持续。熵管理将清理系统化，定期执行，像垃圾回收一样防止技术债积累。
-
-**核心原则**：技术债是高利贷——持续小额偿还远优于积累后大规模清理。
-
-## 铁律
-
-```
-发现的问题不能只修一次——必须同时编码为约束，防止再次发生。
-每次熵管理运行结束后，必须更新质量评分和技术债追踪。
-```
-
-## 触发条件
-
-- 完成 5 个以上任务后（定期维护）
-- `code-reviewer` 审查中反复出现同类问题（模式漂移信号）
-- 用户主动要求代码库健康检查
-- 怀疑文档与代码不一致
-- 新成员加入前（确保仓库状态良好）
-
-## 执行流程
-
-### 第一阶段：自动化传感器扫描
-
-运行 Harness 传感器套件收集机器可检测的问题：
-
-```bash
-node scripts/hooks/dispatcher.cjs stop
-```
-
-记录所有 `[FAIL]` 和 `[WARN]` 项。
-
-### 第二阶段：推理型扫描
-
-自动化传感器无法覆盖的维度，需要人工/Agent 推理检查：
-
-#### 2.1 文档-代码一致性
-
-| 检查项 | 方法 |
-|--------|------|
-| CLAUDE.md 引用路径是否有效 | 逐条验证文件/目录存在 |
-| docs/ 文档描述是否匹配实际行为 | 抽样对比 |
-| SKILL.md 中的流程是否被实际遵循 | 回顾近期任务记录 |
-| 模板是否与当前实践一致 | 对比模板与近期产出 |
-
-#### 2.2 架构漂移检测
-
-| 检查项 | 方法 |
-|--------|------|
-| 是否有文件放在错误目录 | 检查目录约定是否被遵守 |
-| 是否有重复/冗余文件 | 搜索相似文件名和内容 |
-| 技能包结构是否一致 | 抽样检查 SKILL.md 格式 |
-| 协作产物是否在正确位置 | 检查 .orchestration/<session>/ 结构 |
-
-#### 2.3 质量回归检测
-
-| 检查项 | 方法 |
-|--------|------|
-| 近期审查中的高频问题 | 分析 .orchestration/<session>/code-reviewer/ |
-| 是否有被跳过的工作流阶段 | 检查产物完整性 |
-| 是否有"沉默的传感器"（从不报错） | 评估传感器有效性 |
-
-### 第三阶段：修复与编码
-
-对发现的问题分类处理：
-
-| 问题类型 | 处理方式 |
-|---------|---------|
-| 可快速修复的具体问题 | 立即修复（文档更新、文件移动等） |
-| 需要编码为约束的重复模式 | 在 `scripts/hooks/checks/` 加 check，让违规自动触发 [FAIL] |
-| 需要架构讨论的系统性问题 | 与用户讨论；动手前先达成共识 |
-
-### 第四阶段：沉淀与追踪
-
-把本次发现和处理沉淀到下列位置（按相关性挑，不必每次都全做）：
-
-- 反复出现的违规模式 → 在 `scripts/hooks/checks/` 加自动化 check
-- 团队级架构决策 / 新约束 → 写进 `docs/PROJECT_CONTEXT.md` 或 `docs/ARCHITECTURE.md`
-- 跨会话需要记得的代码模式 → 写进 `docs/rules/<topic>.md` 或 `docs/red-flags.md`
-- 用户当前活跃状态 / 个人偏好 → 让 Claude 写进原生 memory（`~/.claude/projects/<slug>/memory/`，自动加载）
-- 新增的危险信号 → 加入 `docs/red-flags.md`
-- 新增的强制规则 → 加入 `docs/rules/<topic>.md`
-
-## 产出清单
-
-每次熵管理运行后，应产出：
-
-```
-✅ dispatcher 扫描结果（node scripts/hooks/dispatcher.cjs stop）
-✅ 推理型扫描发现清单
-✅ 修复的问题列表
-✅ 新增的约束 / check / 规则文档（如有）
-```
-
-## Red Flags — 停下来
-
-| 信号 | 行动 |
-|------|------|
-| 传感器全部通过但直觉上代码库有问题 | 传感器覆盖不足，加新 check |
-| 修复一个漂移又发现三个 | 可能是架构问题，先与用户讨论再动 |
-| 反复出现同类问题但没有沉淀为约束 | 必须在 `scripts/hooks/checks/` 加自动检测 |
-
-## 关联技能
-
-- **verification-before-completion** — 修复后验证
-- **systematic-debugging** — 深入调查发现的问题

package/skills/executing-plans/SKILL.md

@@ -1,70 +0,0 @@
----
-name: executing-plans
-description: Use when you have a written implementation plan to execute in a separate session with review checkpoints
----
-
-# Executing Plans
-
-## Overview
-
-Load plan, review critically, execute all tasks, report when complete.
-
-**Announce at start:** "I'm using the executing-plans skill to implement this plan."
-
-**Note:** When subagents are available (Claude Code / Codex), prefer dispatching per `docs/rules/agents.md` over inline execution — fresh context per task and two-stage review yield higher-quality output. Use this skill when subagent dispatch is unavailable or batched checkpoint execution is preferred.
-
-## The Process
-
-### Step 1: Load and Review Plan
-1. Read plan file
-2. Review critically - identify any questions or concerns about the plan
-3. If concerns: Raise them with your human partner before starting
-4. If no concerns: Create TodoWrite and proceed
-
-### Step 2: Execute Tasks
-
-For each task:
-1. Mark as in_progress
-2. Follow each step exactly (plan has bite-sized steps)
-3. Run verifications as specified
-4. Mark as completed
-
-### Step 3: Complete Development
-
-After all tasks complete and verified:
-- Announce: "I'm using the finishing-a-development-branch skill to complete this work."
-- **REQUIRED SUB-SKILL:** Use superpowers:finishing-a-development-branch
-- Follow that skill to verify tests, present options, execute choice
-
-## When to Stop and Ask for Help
-
-**STOP executing immediately when:**
-- Hit a blocker (missing dependency, test fails, instruction unclear)
-- Plan has critical gaps preventing starting
-- You don't understand an instruction
-- Verification fails repeatedly
-
-**Ask for clarification rather than guessing.**
-
-## When to Revisit Earlier Steps
-
-**Return to Review (Step 1) when:**
-- Partner updates the plan based on your feedback
-- Fundamental approach needs rethinking
-
-**Don't force through blockers** - stop and ask.
-
-## Remember
-- Review plan critically first
-- Follow plan steps exactly
-- Don't skip verifications
-- Reference skills when plan says to
-- Stop when blocked, don't guess
-- Never start implementation on main/master branch without explicit user consent
-
-## Integration
-
-**Required workflow skills:**
-- **superpowers:using-git-worktrees** - REQUIRED: Set up isolated workspace before starting
-- **superpowers:writing-plans** - Creates the plan this skill executes
-- **superpowers:finishing-a-development-branch** - Complete development after all tasks

package/skills/fastapi-expert/SKILL.md

@@ -1,185 +0,0 @@
----
-name: fastapi-expert
-description: "Use when building high-performance async Python APIs with FastAPI and Pydantic V2. Invoke to create REST endpoints, define Pydantic models, implement authentication flows, set up async SQLAlchemy database operations, add JWT authentication, build WebSocket endpoints, or generate OpenAPI documentation. Trigger terms: FastAPI, Pydantic, async Python, Python API, REST API Python, SQLAlchemy async, JWT authentication, OpenAPI, Swagger Python."
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: backend
-  triggers: FastAPI, Pydantic, async Python, Python API, REST API Python, SQLAlchemy async, JWT authentication, OpenAPI, Swagger Python
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: fullstack-guardian, django-expert, test-master
----
-
-# FastAPI Expert
-
-Deep expertise in async Python, Pydantic V2, and production-grade API development with FastAPI.
-
-## When to Use This Skill
-
-- Building REST APIs with FastAPI
-- Implementing Pydantic V2 validation schemas
-- Setting up async database operations
-- Implementing JWT authentication/authorization
-- Creating WebSocket endpoints
-- Optimizing API performance
-
-## Core Workflow
-
-1. **Analyze requirements** — Identify endpoints, data models, auth needs
-2. **Design schemas** — Create Pydantic V2 models for validation
-3. **Implement** — Write async endpoints with proper dependency injection
-4. **Secure** — Add authentication, authorization, rate limiting
-5. **Test** — Write async tests with pytest and httpx; run `pytest` after each endpoint group and verify OpenAPI docs at `/docs`
-
-> **Checkpoint after each step:** confirm schemas validate correctly, endpoints return expected HTTP status codes, and `/docs` reflects the intended API surface before proceeding.
-
-## Minimal Complete Example
-
-Schema + endpoint + dependency injection in one cohesive unit:
-
-```python
-# schemas.py
-from pydantic import BaseModel, EmailStr, field_validator, model_config
-
-class UserCreate(BaseModel):
-    model_config = model_config(str_strip_whitespace=True)
-
-    email: EmailStr
-    password: str
-    name: str | None = None
-
-    @field_validator("password")
-    @classmethod
-    def password_strength(cls, v: str) -> str:
-        if len(v) < 8:
-            raise ValueError("Password must be at least 8 characters")
-        return v
-
-class UserResponse(BaseModel):
-    model_config = model_config(from_attributes=True)
-
-    id: int
-    email: EmailStr
-    name: str | None = None
-```
-
-```python
-# routers/users.py
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.ext.asyncio import AsyncSession
-from typing import Annotated
-
-from app.database import get_db
-from app.schemas import UserCreate, UserResponse
-from app import crud
-
-router = APIRouter(prefix="/users", tags=["users"])
-
-DbDep = Annotated[AsyncSession, Depends(get_db)]
-
-@router.post("/", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
-async def create_user(payload: UserCreate, db: DbDep) -> UserResponse:
-    existing = await crud.get_user_by_email(db, payload.email)
-    if existing:
-        raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Email already registered")
-    return await crud.create_user(db, payload)
-```
-
-```python
-# crud.py
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-from app.models import User
-from app.schemas import UserCreate
-from app.security import hash_password
-
-async def get_user_by_email(db: AsyncSession, email: str) -> User | None:
-    result = await db.execute(select(User).where(User.email == email))
-    return result.scalar_one_or_none()
-
-async def create_user(db: AsyncSession, payload: UserCreate) -> User:
-    user = User(email=payload.email, hashed_password=hash_password(payload.password), name=payload.name)
-    db.add(user)
-    await db.commit()
-    await db.refresh(user)
-    return user
-```
-
-## JWT Authentication Snippet
-
-```python
-# security.py
-from datetime import datetime, timedelta, timezone
-from jose import JWTError, jwt
-from fastapi import Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer
-from typing import Annotated
-
-SECRET_KEY = "read-from-env"  # use os.environ / settings
-ALGORITHM = "HS256"
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/token")
-
-def create_access_token(subject: str, expires_delta: timedelta = timedelta(minutes=30)) -> str:
-    payload = {"sub": subject, "exp": datetime.now(timezone.utc) + expires_delta}
-    return jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
-
-async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]) -> str:
-    try:
-        data = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
-        subject: str | None = data.get("sub")
-        if subject is None:
-            raise ValueError
-        return subject
-    except (JWTError, ValueError):
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
-
-CurrentUser = Annotated[str, Depends(get_current_user)]
-```
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Pydantic V2 | `references/pydantic-v2.md` | Creating schemas, validation, model_config |
-| SQLAlchemy | `references/async-sqlalchemy.md` | Async database, models, CRUD operations |
-| Endpoints | `references/endpoints-routing.md` | APIRouter, dependencies, routing |
-| Authentication | `references/authentication.md` | JWT, OAuth2, get_current_user |
-| Testing | `references/testing-async.md` | pytest-asyncio, httpx, fixtures |
-| Django Migration | `references/migration-from-django.md` | Migrating from Django/DRF to FastAPI |
-
-## Constraints
-
-### MUST DO
-- Use type hints everywhere (FastAPI requires them)
-- Use Pydantic V2 syntax (`field_validator`, `model_validator`, `model_config`)
-- Use `Annotated` pattern for dependency injection
-- Use async/await for all I/O operations
-- Use `X | None` instead of `Optional[X]`
-- Return proper HTTP status codes
-- Document endpoints (auto-generated OpenAPI)
-
-### MUST NOT DO
-- Use synchronous database operations
-- Skip Pydantic validation
-- Store passwords in plain text
-- Expose sensitive data in responses
-- Use Pydantic V1 syntax (`@validator`, `class Config`)
-- Mix sync and async code improperly
-- Hardcode configuration values
-
-## Output Templates
-
-When implementing FastAPI features, provide:
-1. Schema file (Pydantic models)
-2. Endpoint file (router with endpoints)
-3. CRUD operations if database involved
-4. Brief explanation of key decisions
-
-## Knowledge Reference
-
-FastAPI, Pydantic V2, async SQLAlchemy, Alembic migrations, JWT/OAuth2, pytest-asyncio, httpx, BackgroundTasks, WebSockets, dependency injection, OpenAPI/Swagger