autoworkflow 3.1.5 → 3.6.0

package/.claude/skills/csharp.md

@@ -0,0 +1,296 @@
+# C# Skill
+
+## Records (Immutable Data Types)
+\`\`\`csharp
+// Record with positional syntax
+public record User(string Id, string Email, string Name, bool IsActive = true);
+
+// Record with properties
+public record UserResponse
+{
+    public required string Id { get; init; }
+    public required string Email { get; init; }
+    public required string Name { get; init; }
+    public bool IsActive { get; init; } = true;
+}
+
+// With-expressions for copying
+var updatedUser = user with { Name = "New Name", IsActive = false };
+
+// Deconstruction
+var (id, email, name, _) = user;
+
+// Record struct (value type, no heap allocation)
+public readonly record struct Point(int X, int Y);
+\`\`\`
+
+## Nullable Reference Types
+\`\`\`csharp
+// Enable in .csproj: <Nullable>enable</Nullable>
+
+// Non-nullable by default
+public string Name { get; set; }  // Cannot be null
+
+// Explicitly nullable
+public string? MiddleName { get; set; }  // Can be null
+
+// Null-conditional and null-coalescing
+var displayName = user?.Name ?? "Anonymous";
+var length = user?.Name?.Length ?? 0;
+
+// Null-coalescing assignment
+user.Name ??= "Default Name";
+
+// Null-forgiving operator (use sparingly)
+var name = user!.Name;  // Tell compiler this won't be null
+
+// Pattern matching for null checks
+if (user is { Name: not null } u)
+{
+    Console.WriteLine(u.Name);
+}
+
+// Required members (C# 11+)
+public class User
+{
+    public required string Id { get; init; }
+    public required string Email { get; init; }
+    public string? Name { get; init; }
+}
+\`\`\`
+
+## Pattern Matching
+\`\`\`csharp
+// Type patterns
+object obj = GetValue();
+if (obj is string s)
+{
+    Console.WriteLine(s.Length);
+}
+
+// Switch expressions
+string GetStatusMessage(UserStatus status) => status switch
+{
+    UserStatus.Active => "User is active",
+    UserStatus.Pending => "Awaiting verification",
+    UserStatus.Suspended => "Account suspended",
+    UserStatus.Deleted => "Account deleted",
+    _ => throw new ArgumentOutOfRangeException(nameof(status))
+};
+
+// Property patterns
+string Describe(User user) => user switch
+{
+    { IsActive: true, Role: "Admin" } => "Active admin",
+    { IsActive: true } => "Active user",
+    { IsActive: false } => "Inactive user",
+    null => throw new ArgumentNullException(nameof(user))
+};
+
+// Relational and logical patterns
+string GetPriceCategory(decimal price) => price switch
+{
+    < 10 => "Cheap",
+    >= 10 and < 50 => "Moderate",
+    >= 50 and < 100 => "Expensive",
+    >= 100 => "Premium",
+};
+
+// List patterns (C# 11+)
+int[] numbers = { 1, 2, 3, 4, 5 };
+var result = numbers switch
+{
+    [1, 2, ..] => "Starts with 1, 2",
+    [.., 4, 5] => "Ends with 4, 5",
+    [_, _, _, ..] => "Has at least 3 elements",
+    [] => "Empty",
+    _ => "Other"
+};
+\`\`\`
+
+## LINQ
+\`\`\`csharp
+// Query syntax
+var activeUsers = from user in users
+                  where user.IsActive
+                  orderby user.CreatedAt descending
+                  select new { user.Id, user.Email };
+
+// Method syntax (more common)
+var result = users
+    .Where(u => u.IsActive)
+    .OrderByDescending(u => u.CreatedAt)
+    .Select(u => new { u.Id, u.Email })
+    .ToList();
+
+// Common operations
+var first = users.FirstOrDefault(u => u.Email == email);
+var any = users.Any(u => u.IsActive);
+var all = users.All(u => u.Email.Contains("@"));
+var count = users.Count(u => u.IsActive);
+
+// Grouping
+var byDomain = users
+    .GroupBy(u => u.Email.Split('@')[1])
+    .Select(g => new { Domain = g.Key, Count = g.Count() });
+
+// Join
+var usersWithPosts = users.Join(
+    posts,
+    u => u.Id,
+    p => p.AuthorId,
+    (user, post) => new { User = user, Post = post }
+);
+
+// Aggregation
+var stats = users
+    .GroupBy(u => u.Department)
+    .Select(g => new
+    {
+        Department = g.Key,
+        Count = g.Count(),
+        AvgSalary = g.Average(u => u.Salary),
+        MaxSalary = g.Max(u => u.Salary)
+    });
+
+// SelectMany for flattening
+var allTags = posts
+    .SelectMany(p => p.Tags)
+    .Distinct()
+    .ToList();
+
+// Chunk (C# 11+ / .NET 6+)
+var batches = users.Chunk(100);
+foreach (var batch in batches)
+{
+    await ProcessBatch(batch);
+}
+\`\`\`
+
+## Async/Await
+\`\`\`csharp
+// Async method
+public async Task<User?> GetUserAsync(string id, CancellationToken ct = default)
+{
+    return await _context.Users
+        .FirstOrDefaultAsync(u => u.Id == id, ct);
+}
+
+// Multiple async operations
+public async Task<UserWithPosts> GetUserWithPostsAsync(string userId)
+{
+    var userTask = GetUserAsync(userId);
+    var postsTask = GetPostsAsync(userId);
+
+    await Task.WhenAll(userTask, postsTask);
+
+    return new UserWithPosts(userTask.Result!, postsTask.Result);
+}
+
+// Async streams
+public async IAsyncEnumerable<User> GetUsersStreamAsync(
+    [EnumeratorCancellation] CancellationToken ct = default)
+{
+    await foreach (var user in _context.Users.AsAsyncEnumerable().WithCancellation(ct))
+    {
+        yield return user;
+    }
+}
+
+// ValueTask for high-performance scenarios
+public ValueTask<User?> GetCachedUserAsync(string id)
+{
+    if (_cache.TryGetValue(id, out var user))
+    {
+        return ValueTask.FromResult<User?>(user);
+    }
+    return new ValueTask<User?>(FetchUserAsync(id));
+}
+
+// ConfigureAwait for library code
+public async Task<string> LibraryMethodAsync()
+{
+    var result = await SomeOperationAsync().ConfigureAwait(false);
+    return result.ToString();
+}
+\`\`\`
+
+## Collections
+\`\`\`csharp
+// Immutable collections
+using System.Collections.Immutable;
+
+ImmutableList<string> names = ImmutableList.Create("Alice", "Bob");
+var newNames = names.Add("Charlie");  // Returns new list
+
+// Collection expressions (C# 12+)
+List<int> numbers = [1, 2, 3, 4, 5];
+int[] array = [1, 2, 3];
+Span<int> span = [1, 2, 3];
+
+// Spread operator
+int[] combined = [..array1, ..array2];
+
+// Dictionary patterns
+var userById = users.ToDictionary(u => u.Id);
+var count = userById.GetValueOrDefault(id)?.Posts.Count ?? 0;
+
+// Concurrent collections
+var cache = new ConcurrentDictionary<string, User>();
+var user = cache.GetOrAdd(id, _ => FetchUser(id));
+\`\`\`
+
+## Exception Handling
+\`\`\`csharp
+// Custom exception
+public class NotFoundException : Exception
+{
+    public string ResourceType { get; }
+    public string ResourceId { get; }
+
+    public NotFoundException(string resourceType, string resourceId)
+        : base($"{resourceType} with id '{resourceId}' not found")
+    {
+        ResourceType = resourceType;
+        ResourceId = resourceId;
+    }
+}
+
+// Try pattern
+public bool TryGetUser(string id, out User? user)
+{
+    user = _users.FirstOrDefault(u => u.Id == id);
+    return user is not null;
+}
+
+// Exception filters
+try
+{
+    await httpClient.GetAsync(url);
+}
+catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
+{
+    return null;
+}
+catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.Unauthorized)
+{
+    throw new AuthenticationException("Invalid credentials", ex);
+}
+\`\`\`
+
+## ✅ DO
+- Use records for immutable data (DTOs, value objects)
+- Enable nullable reference types
+- Use pattern matching for type checks and deconstruction
+- Use \`async/await\` throughout - avoid \`.Result\` and \`.Wait()\`
+- Pass \`CancellationToken\` to async methods
+- Use collection expressions (C# 12+)
+- Use \`required\` for mandatory properties
+
+## ❌ DON'T
+- Don't use \`async void\` except for event handlers
+- Don't ignore \`CancellationToken\`
+- Don't use \`?.Result\` on tasks (can deadlock)
+- Don't catch \`Exception\` without rethrowing or logging
+- Don't use \`null!\` to silence nullable warnings
+- Don't use mutable collections when immutable suffice

package/.claude/skills/css-modules.md

@@ -0,0 +1,325 @@
+# CSS Modules Skill
+
+## Basic Usage
+\`\`\`tsx
+// Button.module.css
+.button {
+  padding: 0.5rem 1rem;
+  border: none;
+  border-radius: 0.375rem;
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+.primary {
+  background: #3b82f6;
+  color: white;
+}
+
+.primary:hover {
+  background: #2563eb;
+}
+
+.secondary {
+  background: #6b7280;
+  color: white;
+}
+
+// Button.tsx
+import styles from './Button.module.css';
+
+interface ButtonProps {
+  variant?: 'primary' | 'secondary';
+  children: React.ReactNode;
+}
+
+export function Button({ variant = 'primary', children }: ButtonProps) {
+  return (
+    <button className={\`\${styles.button} \${styles[variant]}\`}>
+      {children}
+    </button>
+  );
+}
+\`\`\`
+
+## Composition (composes)
+\`\`\`css
+/* shared.module.css */
+.flexCenter {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.truncate {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* Card.module.css */
+.card {
+  composes: flexCenter from './shared.module.css';
+  padding: 1.5rem;
+  border-radius: 0.5rem;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+.title {
+  composes: truncate from './shared.module.css';
+  font-size: 1.25rem;
+  font-weight: 600;
+}
+
+/* Multiple compositions */
+.header {
+  composes: flexCenter truncate from './shared.module.css';
+}
+\`\`\`
+
+## Global Styles
+\`\`\`css
+/* Component.module.css */
+
+/* Local class (default) */
+.container {
+  padding: 1rem;
+}
+
+/* Global class within module */
+:global(.external-library-class) {
+  color: red;
+}
+
+/* Mix local and global */
+.container :global(.markdown-body) {
+  line-height: 1.6;
+}
+
+/* Global block */
+:global {
+  .some-global-class {
+    color: blue;
+  }
+
+  body.dark-mode {
+    background: #1a1a1a;
+  }
+}
+\`\`\`
+
+## Combining Classes
+\`\`\`tsx
+import styles from './Button.module.css';
+import clsx from 'clsx';  // or classnames library
+
+interface ButtonProps {
+  variant?: 'primary' | 'secondary';
+  size?: 'sm' | 'md' | 'lg';
+  disabled?: boolean;
+  fullWidth?: boolean;
+  className?: string;
+  children: React.ReactNode;
+}
+
+export function Button({
+  variant = 'primary',
+  size = 'md',
+  disabled,
+  fullWidth,
+  className,
+  children,
+}: ButtonProps) {
+  return (
+    <button
+      className={clsx(
+        styles.button,
+        styles[variant],
+        styles[size],
+        {
+          [styles.disabled]: disabled,
+          [styles.fullWidth]: fullWidth,
+        },
+        className  // Allow external classes
+      )}
+      disabled={disabled}
+    >
+      {children}
+    </button>
+  );
+}
+
+// Button.module.css
+.button { /* base styles */ }
+.primary { /* primary variant */ }
+.secondary { /* secondary variant */ }
+.sm { padding: 0.25rem 0.5rem; font-size: 0.875rem; }
+.md { padding: 0.5rem 1rem; }
+.lg { padding: 0.75rem 1.5rem; font-size: 1.125rem; }
+.disabled { opacity: 0.5; cursor: not-allowed; }
+.fullWidth { width: 100%; }
+\`\`\`
+
+## CSS Variables Integration
+\`\`\`css
+/* variables.css (global) */
+:root {
+  --color-primary: #3b82f6;
+  --color-secondary: #6b7280;
+  --color-danger: #ef4444;
+  --spacing-sm: 0.5rem;
+  --spacing-md: 1rem;
+  --spacing-lg: 1.5rem;
+  --border-radius: 0.375rem;
+  --shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+}
+
+[data-theme='dark'] {
+  --color-background: #1a1a1a;
+  --color-text: #ffffff;
+}
+
+/* Button.module.css */
+.button {
+  padding: var(--spacing-sm) var(--spacing-md);
+  border-radius: var(--border-radius);
+  box-shadow: var(--shadow);
+}
+
+.primary {
+  background: var(--color-primary);
+}
+\`\`\`
+
+## TypeScript Support
+\`\`\`tsx
+// For TypeScript, you need type declarations
+
+// Option 1: Global declaration (global.d.ts)
+declare module '*.module.css' {
+  const classes: { [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.scss' {
+  const classes: { [key: string]: string };
+  export default classes;
+}
+
+// Option 2: Use typed-css-modules or css-modules-typescript-loader
+// This generates .d.ts files for each module
+
+// Button.module.css.d.ts (auto-generated)
+declare const styles: {
+  readonly button: string;
+  readonly primary: string;
+  readonly secondary: string;
+};
+export default styles;
+
+// Now TypeScript knows the available classes
+import styles from './Button.module.css';
+styles.button;   // OK
+styles.primary;  // OK
+styles.invalid;  // TypeScript error!
+\`\`\`
+
+## With Sass/SCSS
+\`\`\`scss
+// Button.module.scss
+$primary: #3b82f6;
+$secondary: #6b7280;
+
+@mixin button-base {
+  padding: 0.5rem 1rem;
+  border: none;
+  border-radius: 0.375rem;
+  cursor: pointer;
+  transition: all 0.2s;
+}
+
+.button {
+  @include button-base;
+}
+
+.primary {
+  background: $primary;
+  color: white;
+
+  &:hover {
+    background: darken($primary, 10%);
+  }
+}
+
+.secondary {
+  background: $secondary;
+  color: white;
+
+  &:hover {
+    background: darken($secondary, 10%);
+  }
+}
+
+// Nesting works as expected
+.card {
+  padding: 1.5rem;
+
+  &__title {
+    font-size: 1.25rem;
+  }
+
+  &__content {
+    color: #6b7280;
+  }
+}
+\`\`\`
+
+## File Structure
+\`\`\`
+src/
+├── components/
+│   ├── Button/
+│   │   ├── Button.tsx
+│   │   ├── Button.module.css
+│   │   └── index.ts
+│   └── Card/
+│       ├── Card.tsx
+│       ├── Card.module.css
+│       └── index.ts
+├── styles/
+│   ├── variables.css     # CSS custom properties
+│   ├── shared.module.css # Shared compositions
+│   └── global.css        # Global styles
+└── App.tsx
+\`\`\`
+
+## Configuration (Vite)
+\`\`\`typescript
+// vite.config.ts
+export default defineConfig({
+  css: {
+    modules: {
+      localsConvention: 'camelCaseOnly',  // .my-class → styles.myClass
+      generateScopedName: '[name]__[local]___[hash:base64:5]',
+    },
+  },
+});
+
+// Next.js works out of the box with .module.css
+\`\`\`
+
+## ❌ DON'T
+- Use generic class names that don't describe the component
+- Deeply nest selectors (keep flat)
+- Mix global and local styles unnecessarily
+- Forget to handle dynamic class names in TypeScript
+- Create overly long class name strings
+
+## ✅ DO
+- Name files with .module.css suffix
+- Use composes for shared styles
+- Use CSS variables for theming
+- Use clsx/classnames for combining classes
+- Set up TypeScript declarations
+- Keep styles colocated with components
+- Use BEM-like naming within modules for nested elements