autoworkflow 3.1.4 → 3.5.0

package/.claude/skills/aspnet-core.md

@@ -0,0 +1,377 @@
+# ASP.NET Core Skill
+
+## Program.cs (Minimal API)
+\`\`\`csharp
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services
+builder.Services.AddControllers();
+builder.Services.AddEndpointsApiExplorer();
+builder.Services.AddSwaggerGen();
+
+// Custom services
+builder.Services.AddScoped<IUserService, UserService>();
+builder.Services.AddDbContext<AppDbContext>(options =>
+    options.UseNpgsql(builder.Configuration.GetConnectionString("Default")));
+
+// Authentication
+builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+    .AddJwtBearer(options =>
+    {
+        options.TokenValidationParameters = new TokenValidationParameters
+        {
+            ValidateIssuer = true,
+            ValidateAudience = true,
+            ValidateLifetime = true,
+            ValidIssuer = builder.Configuration["Jwt:Issuer"],
+            ValidAudience = builder.Configuration["Jwt:Audience"],
+            IssuerSigningKey = new SymmetricSecurityKey(
+                Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]!))
+        };
+    });
+
+builder.Services.AddAuthorization();
+
+var app = builder.Build();
+
+// Middleware pipeline
+if (app.Environment.IsDevelopment())
+{
+    app.UseSwagger();
+    app.UseSwaggerUI();
+}
+
+app.UseExceptionHandler("/error");
+app.UseHttpsRedirection();
+app.UseAuthentication();
+app.UseAuthorization();
+
+app.MapControllers();
+
+app.Run();
+\`\`\`
+
+## Controller Pattern
+\`\`\`csharp
+[ApiController]
+[Route("api/v1/[controller]")]
+[Produces("application/json")]
+public class UsersController : ControllerBase
+{
+    private readonly IUserService _userService;
+
+    public UsersController(IUserService userService)
+    {
+        _userService = userService;
+    }
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResult<UserResponse>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResult<UserResponse>>> GetUsers(
+        [FromQuery] int page = 1,
+        [FromQuery] int pageSize = 20,
+        CancellationToken ct = default)
+    {
+        var result = await _userService.GetAllAsync(page, pageSize, ct);
+        return Ok(result);
+    }
+
+    [HttpGet("{id}")]
+    [ProducesResponseType(typeof(UserResponse), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<UserResponse>> GetUser(string id, CancellationToken ct)
+    {
+        var user = await _userService.GetByIdAsync(id, ct);
+        return user is null ? NotFound() : Ok(user);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(UserResponse), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ValidationProblemDetails), StatusCodes.Status400BadRequest)]
+    public async Task<ActionResult<UserResponse>> CreateUser(
+        [FromBody] CreateUserRequest request,
+        CancellationToken ct)
+    {
+        var user = await _userService.CreateAsync(request, ct);
+        return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);
+    }
+
+    [HttpPut("{id}")]
+    [ProducesResponseType(typeof(UserResponse), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<UserResponse>> UpdateUser(
+        string id,
+        [FromBody] UpdateUserRequest request,
+        CancellationToken ct)
+    {
+        var user = await _userService.UpdateAsync(id, request, ct);
+        return user is null ? NotFound() : Ok(user);
+    }
+
+    [HttpDelete("{id}")]
+    [Authorize(Roles = "Admin")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> DeleteUser(string id, CancellationToken ct)
+    {
+        var deleted = await _userService.DeleteAsync(id, ct);
+        return deleted ? NoContent() : NotFound();
+    }
+}
+\`\`\`
+
+## Minimal APIs
+\`\`\`csharp
+var app = builder.Build();
+
+// Group routes
+var users = app.MapGroup("/api/v1/users")
+    .WithTags("Users");
+
+users.MapGet("/", async (IUserService service, CancellationToken ct) =>
+    await service.GetAllAsync(ct));
+
+users.MapGet("/{id}", async (string id, IUserService service, CancellationToken ct) =>
+    await service.GetByIdAsync(id, ct) is { } user
+        ? Results.Ok(user)
+        : Results.NotFound());
+
+users.MapPost("/", async (CreateUserRequest request, IUserService service, CancellationToken ct) =>
+{
+    var user = await service.CreateAsync(request, ct);
+    return Results.Created($"/api/v1/users/{user.Id}", user);
+})
+.RequireAuthorization();
+
+// With validation
+users.MapPost("/", async (
+    [FromBody] CreateUserRequest request,
+    IValidator<CreateUserRequest> validator,
+    IUserService service,
+    CancellationToken ct) =>
+{
+    var validation = await validator.ValidateAsync(request, ct);
+    if (!validation.IsValid)
+    {
+        return Results.ValidationProblem(validation.ToDictionary());
+    }
+    var user = await service.CreateAsync(request, ct);
+    return Results.Created($"/api/v1/users/{user.Id}", user);
+});
+\`\`\`
+
+## Validation with FluentValidation
+\`\`\`csharp
+public record CreateUserRequest(string Email, string Name, string Password);
+
+public class CreateUserRequestValidator : AbstractValidator<CreateUserRequest>
+{
+    public CreateUserRequestValidator()
+    {
+        RuleFor(x => x.Email)
+            .NotEmpty()
+            .EmailAddress()
+            .MaximumLength(255);
+
+        RuleFor(x => x.Name)
+            .NotEmpty()
+            .MinimumLength(2)
+            .MaximumLength(100);
+
+        RuleFor(x => x.Password)
+            .NotEmpty()
+            .MinimumLength(8)
+            .Matches("[A-Z]").WithMessage("Password must contain uppercase letter")
+            .Matches("[0-9]").WithMessage("Password must contain digit");
+    }
+}
+
+// Registration
+builder.Services.AddValidatorsFromAssemblyContaining<Program>();
+\`\`\`
+
+## Exception Handling
+\`\`\`csharp
+// Global exception handler
+public class GlobalExceptionHandler : IExceptionHandler
+{
+    private readonly ILogger<GlobalExceptionHandler> _logger;
+
+    public GlobalExceptionHandler(ILogger<GlobalExceptionHandler> logger)
+    {
+        _logger = logger;
+    }
+
+    public async ValueTask<bool> TryHandleAsync(
+        HttpContext context,
+        Exception exception,
+        CancellationToken ct)
+    {
+        _logger.LogError(exception, "Exception occurred: {Message}", exception.Message);
+
+        var (statusCode, response) = exception switch
+        {
+            NotFoundException e => (StatusCodes.Status404NotFound,
+                new ProblemDetails { Title = "Not Found", Detail = e.Message }),
+            ValidationException e => (StatusCodes.Status400BadRequest,
+                new ProblemDetails { Title = "Validation Error", Detail = e.Message }),
+            UnauthorizedAccessException => (StatusCodes.Status401Unauthorized,
+                new ProblemDetails { Title = "Unauthorized" }),
+            _ => (StatusCodes.Status500InternalServerError,
+                new ProblemDetails { Title = "Internal Server Error" })
+        };
+
+        context.Response.StatusCode = statusCode;
+        await context.Response.WriteAsJsonAsync(response, ct);
+        return true;
+    }
+}
+
+// Registration
+builder.Services.AddExceptionHandler<GlobalExceptionHandler>();
+builder.Services.AddProblemDetails();
+
+// In pipeline
+app.UseExceptionHandler();
+\`\`\`
+
+## Middleware
+\`\`\`csharp
+public class RequestTimingMiddleware
+{
+    private readonly RequestDelegate _next;
+    private readonly ILogger<RequestTimingMiddleware> _logger;
+
+    public RequestTimingMiddleware(RequestDelegate next, ILogger<RequestTimingMiddleware> logger)
+    {
+        _next = next;
+        _logger = logger;
+    }
+
+    public async Task InvokeAsync(HttpContext context)
+    {
+        var stopwatch = Stopwatch.StartNew();
+
+        try
+        {
+            await _next(context);
+        }
+        finally
+        {
+            stopwatch.Stop();
+            _logger.LogInformation(
+                "{Method} {Path} responded {StatusCode} in {ElapsedMs}ms",
+                context.Request.Method,
+                context.Request.Path,
+                context.Response.StatusCode,
+                stopwatch.ElapsedMilliseconds);
+        }
+    }
+}
+
+// Registration
+app.UseMiddleware<RequestTimingMiddleware>();
+
+// Or as extension method
+public static class MiddlewareExtensions
+{
+    public static IApplicationBuilder UseRequestTiming(this IApplicationBuilder app)
+        => app.UseMiddleware<RequestTimingMiddleware>();
+}
+\`\`\`
+
+## Configuration
+\`\`\`csharp
+// appsettings.json
+{
+  "ConnectionStrings": {
+    "Default": "Host=localhost;Database=myapp;Username=postgres;Password=secret"
+  },
+  "Jwt": {
+    "Key": "your-secret-key-here",
+    "Issuer": "your-app",
+    "Audience": "your-app"
+  }
+}
+
+// Strongly-typed configuration
+public class JwtSettings
+{
+    public required string Key { get; init; }
+    public required string Issuer { get; init; }
+    public required string Audience { get; init; }
+    public int ExpirationMinutes { get; init; } = 60;
+}
+
+// Registration
+builder.Services.Configure<JwtSettings>(builder.Configuration.GetSection("Jwt"));
+
+// Usage
+public class TokenService
+{
+    private readonly JwtSettings _settings;
+
+    public TokenService(IOptions<JwtSettings> options)
+    {
+        _settings = options.Value;
+    }
+}
+\`\`\`
+
+## Testing
+\`\`\`csharp
+public class UsersControllerTests : IClassFixture<WebApplicationFactory<Program>>
+{
+    private readonly HttpClient _client;
+
+    public UsersControllerTests(WebApplicationFactory<Program> factory)
+    {
+        _client = factory.WithWebHostBuilder(builder =>
+        {
+            builder.ConfigureServices(services =>
+            {
+                // Replace with test database
+                services.RemoveAll<DbContextOptions<AppDbContext>>();
+                services.AddDbContext<AppDbContext>(options =>
+                    options.UseInMemoryDatabase("TestDb"));
+            });
+        }).CreateClient();
+    }
+
+    [Fact]
+    public async Task GetUser_ReturnsUser_WhenExists()
+    {
+        var response = await _client.GetAsync("/api/v1/users/1");
+
+        response.StatusCode.Should().Be(HttpStatusCode.OK);
+        var user = await response.Content.ReadFromJsonAsync<UserResponse>();
+        user.Should().NotBeNull();
+    }
+
+    [Fact]
+    public async Task CreateUser_ReturnsCreated_WithValidData()
+    {
+        var request = new CreateUserRequest("test@example.com", "Test", "Password123");
+
+        var response = await _client.PostAsJsonAsync("/api/v1/users", request);
+
+        response.StatusCode.Should().Be(HttpStatusCode.Created);
+        response.Headers.Location.Should().NotBeNull();
+    }
+}
+\`\`\`
+
+## ✅ DO
+- Use \`[ApiController]\` attribute for automatic model validation
+- Use \`CancellationToken\` in all async endpoints
+- Return \`ActionResult<T>\` for typed responses
+- Use \`IOptions<T>\` for configuration
+- Use global exception handling
+- Use ProblemDetails for error responses
+
+## ❌ DON'T
+- Don't inject \`IConfiguration\` directly - use \`IOptions<T>\`
+- Don't use \`[FromBody]\` on complex types with \`[ApiController]\`
+- Don't forget \`ConfigureAwait(false)\` in library code
+- Don't catch exceptions in controllers - use global handler
+- Don't return entities - use DTOs/records

package/.claude/skills/astro.md

@@ -0,0 +1,245 @@
+# Astro Skill
+
+## Project Structure
+\`\`\`
+src/
+├── pages/              # File-based routing
+│   ├── index.astro     # /
+│   ├── about.astro     # /about
+│   ├── posts/
+│   │   ├── index.astro # /posts
+│   │   └── [slug].astro # /posts/:slug
+│   └── api/
+│       └── users.ts    # API endpoint
+├── layouts/            # Page layouts
+├── components/         # UI components
+├── content/            # Content collections
+│   └── blog/
+│       ├── post-1.md
+│       └── post-2.mdx
+└── styles/             # Global styles
+\`\`\`
+
+## Astro Components
+\`\`\`astro
+---
+// Component script (runs at build time)
+import Layout from '../layouts/Layout.astro';
+import Card from '../components/Card.astro';
+
+// Props
+interface Props {
+  title: string;
+  description?: string;
+}
+
+const { title, description = 'Default description' } = Astro.props;
+
+// Fetch data at build time
+const response = await fetch('https://api.example.com/posts');
+const posts = await response.json();
+
+// Access URL params
+const { slug } = Astro.params;
+---
+
+<Layout title={title}>
+  <h1>{title}</h1>
+  <p>{description}</p>
+
+  <ul>
+    {posts.map((post) => (
+      <li>
+        <Card title={post.title} href={\`/posts/\${post.slug}\`} />
+      </li>
+    ))}
+  </ul>
+</Layout>
+
+<style>
+  /* Scoped styles by default */
+  h1 {
+    color: navy;
+  }
+</style>
+\`\`\`
+
+## Component Islands (Partial Hydration)
+\`\`\`astro
+---
+import ReactCounter from './Counter.tsx';
+import VueWidget from './Widget.vue';
+import SvelteForm from './Form.svelte';
+---
+
+<!-- No JS - static HTML only -->
+<ReactCounter />
+
+<!-- Hydrate immediately on page load -->
+<ReactCounter client:load />
+
+<!-- Hydrate when component is visible -->
+<ReactCounter client:visible />
+
+<!-- Hydrate on idle (requestIdleCallback) -->
+<ReactCounter client:idle />
+
+<!-- Hydrate on media query match -->
+<VueWidget client:media="(max-width: 768px)" />
+
+<!-- Hydrate only on client (skip SSR) -->
+<SvelteForm client:only="svelte" />
+\`\`\`
+
+## Content Collections
+\`\`\`typescript
+// src/content/config.ts
+import { defineCollection, z } from 'astro:content';
+
+const blogCollection = defineCollection({
+  type: 'content',
+  schema: z.object({
+    title: z.string(),
+    description: z.string(),
+    pubDate: z.date(),
+    author: z.string(),
+    tags: z.array(z.string()).optional(),
+    image: z.string().optional(),
+  }),
+});
+
+export const collections = {
+  blog: blogCollection,
+};
+
+// Usage in pages
+---
+import { getCollection, getEntry } from 'astro:content';
+
+// Get all posts
+const posts = await getCollection('blog');
+
+// Filter posts
+const publishedPosts = await getCollection('blog', ({ data }) => {
+  return data.pubDate < new Date();
+});
+
+// Get single entry
+const post = await getEntry('blog', 'my-post-slug');
+---
+
+{posts.map((post) => (
+  <article>
+    <h2>{post.data.title}</h2>
+    <time>{post.data.pubDate.toDateString()}</time>
+  </article>
+))}
+\`\`\`
+
+## Dynamic Routes
+\`\`\`astro
+---
+// src/pages/posts/[slug].astro
+import { getCollection } from 'astro:content';
+
+export async function getStaticPaths() {
+  const posts = await getCollection('blog');
+  return posts.map((post) => ({
+    params: { slug: post.slug },
+    props: { post },
+  }));
+}
+
+const { post } = Astro.props;
+const { Content } = await post.render();
+---
+
+<article>
+  <h1>{post.data.title}</h1>
+  <Content />
+</article>
+\`\`\`
+
+## API Routes
+\`\`\`typescript
+// src/pages/api/users.ts
+import type { APIRoute } from 'astro';
+
+export const GET: APIRoute = async ({ request }) => {
+  const users = await db.user.findMany();
+
+  return new Response(JSON.stringify(users), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' },
+  });
+};
+
+export const POST: APIRoute = async ({ request }) => {
+  const data = await request.json();
+
+  const user = await db.user.create({ data });
+
+  return new Response(JSON.stringify(user), {
+    status: 201,
+    headers: { 'Content-Type': 'application/json' },
+  });
+};
+\`\`\`
+
+## Middleware
+\`\`\`typescript
+// src/middleware.ts
+import { defineMiddleware } from 'astro:middleware';
+
+export const onRequest = defineMiddleware(async (context, next) => {
+  // Run before each page/endpoint
+  const token = context.cookies.get('token');
+
+  if (token) {
+    context.locals.user = await validateToken(token.value);
+  }
+
+  // Protected routes
+  if (context.url.pathname.startsWith('/dashboard') && !context.locals.user) {
+    return context.redirect('/login');
+  }
+
+  return next();
+});
+\`\`\`
+
+## SSR Mode (Hybrid/Server)
+\`\`\`typescript
+// astro.config.mjs
+export default defineConfig({
+  output: 'hybrid', // or 'server' for full SSR
+
+  adapter: vercel(), // or netlify(), node(), etc.
+});
+
+// Per-page opt-in/out
+---
+// Static page in hybrid mode
+export const prerender = true;
+---
+
+---
+// Dynamic page (SSR)
+export const prerender = false;
+const user = Astro.locals.user;
+---
+\`\`\`
+
+## ❌ DON'T
+- Hydrate everything (defeats the purpose)
+- Use client:load when client:visible works
+- Forget to define content collection schemas
+- Skip prerender in hybrid mode for static pages
+
+## ✅ DO
+- Default to zero JavaScript
+- Hydrate only interactive components
+- Use content collections for structured content
+- Use middleware for auth/redirects
+- Choose the right hydration directive
+- Use hybrid mode for mixed static/dynamic