claude-code-pilot 3.2.0 → 3.3.1

package/src/skills/fsharp-testing/SKILL.md

@@ -0,0 +1,280 @@
+---
+name: fsharp-testing
+description: F# testing patterns with xUnit, FsUnit, Unquote, FsCheck property-based testing, integration tests, and test organization best practices.
+origin: ECC
+---
+
+# F# Testing Patterns
+
+Comprehensive testing patterns for F# applications using xUnit, FsUnit, Unquote, FsCheck, and modern .NET testing practices.
+
+## When to Activate
+
+- Writing new tests for F# code
+- Reviewing test quality and coverage
+- Setting up test infrastructure for F# projects
+- Debugging flaky or slow tests
+
+## Test Framework Stack
+
+| Tool | Purpose |
+|---|---|
+| **xUnit** | Test framework (standard .NET ecosystem choice) |
+| **FsUnit.xUnit** | F#-friendly assertion syntax for xUnit |
+| **Unquote** | Assertion library using F# quotations for clear failure messages |
+| **FsCheck.xUnit** | Property-based testing integrated with xUnit |
+| **NSubstitute** | Mocking .NET dependencies |
+| **Testcontainers** | Real infrastructure in integration tests |
+| **WebApplicationFactory** | ASP.NET Core integration tests |
+
+## Unit Tests with xUnit + FsUnit
+
+### Basic Test Structure
+
+```fsharp
+module OrderServiceTests
+
+open Xunit
+open FsUnit.Xunit
+
+[<Fact>]
+let ``create sets status to Pending`` () =
+    let order = Order.create "cust-1" [ validItem ]
+    order.Status |> should equal Pending
+
+[<Fact>]
+let ``confirm changes status to Confirmed`` () =
+    let order = Order.create "cust-1" [ validItem ]
+    let confirmed = Order.confirm order
+    confirmed.Status |> should be (ofCase <@ Confirmed @>)
+```
+
+### Assertions with Unquote
+
+Unquote uses F# quotations so failure messages show the full expression that failed, not just "expected X got Y".
+
+```fsharp
+module OrderValidationTests
+
+open Xunit
+open Swensen.Unquote
+
+[<Fact>]
+let ``PlaceOrder returns success when request is valid`` () =
+    let request = { CustomerId = "cust-123"; Items = [ validItem ] }
+    let result = OrderService.placeOrder request
+    test <@ Result.isOk result @>
+
+[<Fact>]
+let ``order total sums item prices`` () =
+    let items = [ { Sku = "A"; Quantity = 2; Price = 10m }
+                  { Sku = "B"; Quantity = 1; Price = 5m } ]
+    let total = Order.calculateTotal items
+    test <@ total = 25m @>
+
+[<Fact>]
+let ``validated email rejects empty input`` () =
+    let result = ValidatedEmail.create ""
+    test <@ Result.isError result @>
+```
+
+### Async Tests
+
+```fsharp
+[<Fact>]
+let ``PlaceOrder returns success when request is valid`` () = task {
+    let deps = createTestDeps ()
+    let request = { CustomerId = "cust-123"; Items = [ validItem ] }
+
+    let! result = OrderService.placeOrder deps request
+
+    test <@ Result.isOk result @>
+}
+
+[<Fact>]
+let ``PlaceOrder returns error when items are empty`` () = task {
+    let deps = createTestDeps ()
+    let request = { CustomerId = "cust-123"; Items = [] }
+
+    let! result = OrderService.placeOrder deps request
+
+    test <@ Result.isError result @>
+}
+```
+
+### Parameterized Tests with Theory
+
+```fsharp
+[<Theory>]
+[<InlineData("")>]
+[<InlineData("   ")>]
+let ``PlaceOrder rejects empty customer ID`` (customerId: string) =
+    let request = { CustomerId = customerId; Items = [ validItem ] }
+    let result = OrderService.placeOrder request
+    result |> should be (ofCase <@ Error @>)
+
+[<Theory>]
+[<InlineData("", false)>]
+[<InlineData("a", false)>]
+[<InlineData("user@example.com", true)>]
+[<InlineData("user+tag@example.co.uk", true)>]
+let ``IsValidEmail returns expected result`` (email: string, expected: bool) =
+    test <@ EmailValidator.isValid email = expected @>
+```
+
+## Property-Based Testing with FsCheck
+
+### Using FsCheck.xUnit
+
+```fsharp
+open FsCheck
+open FsCheck.Xunit
+
+[<Property>]
+let ``order total is always non-negative`` (items: NonEmptyList<PositiveInt * decimal>) =
+    let orderItems =
+        items.Get
+        |> List.map (fun (qty, price) ->
+            { Sku = "SKU"; Quantity = qty.Get; Price = abs price })
+    let total = Order.calculateTotal orderItems
+    total >= 0m
+
+[<Property>]
+let ``serialization roundtrips`` (order: Order) =
+    let json = JsonSerializer.Serialize order
+    let deserialized = JsonSerializer.Deserialize<Order> json
+    deserialized = order
+```
+
+### Custom Generators
+
+```fsharp
+type OrderGenerators =
+    static member ValidEmail () =
+        gen {
+            let! user = Gen.elements [ "alice"; "bob"; "carol" ]
+            let! domain = Gen.elements [ "example.com"; "test.org" ]
+            return $"{user}@{domain}"
+        }
+        |> Arb.fromGen
+
+[<Property(Arbitrary = [| typeof<OrderGenerators> |])>]
+let ``valid emails pass validation`` (email: string) =
+    EmailValidator.isValid email
+```
+
+## Mocking Dependencies
+
+### Function Stubs (Preferred)
+
+```fsharp
+let createTestDeps () =
+    let mutable savedOrders = []
+    { FindOrder = fun id -> task { return Map.tryFind id testData }
+      SaveOrder = fun order -> task { savedOrders <- order :: savedOrders }
+      SendNotification = fun _ -> Task.CompletedTask }
+
+[<Fact>]
+let ``PlaceOrder saves the confirmed order`` () = task {
+    let mutable saved = []
+    let deps =
+        { createTestDeps () with
+            SaveOrder = fun order -> task { saved <- order :: saved } }
+
+    let! _ = OrderService.placeOrder deps validRequest
+
+    test <@ saved.Length = 1 @>
+}
+```
+
+### NSubstitute for .NET Interfaces
+
+```fsharp
+open NSubstitute
+
+[<Fact>]
+let ``calls repository with correct ID`` () = task {
+    let repo = Substitute.For<IOrderRepository>()
+    repo.FindByIdAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>())
+        .Returns(Task.FromResult(Some testOrder))
+
+    let service = OrderService(repo)
+    let! _ = service.GetOrder(testOrder.Id, CancellationToken.None)
+
+    do! repo.Received(1).FindByIdAsync(testOrder.Id, Arg.Any<CancellationToken>())
+}
+```
+
+## ASP.NET Core Integration Tests
+
+```fsharp
+type OrderApiTests (factory: WebApplicationFactory<Program>) =
+    interface IClassFixture<WebApplicationFactory<Program>>
+
+    let client =
+        factory.WithWebHostBuilder(fun builder ->
+            builder.ConfigureServices(fun services ->
+                services.RemoveAll<DbContextOptions<AppDbContext>>() |> ignore
+                services.AddDbContext<AppDbContext>(fun options ->
+                    options.UseInMemoryDatabase("TestDb") |> ignore) |> ignore))
+            .CreateClient()
+
+    [<Fact>]
+    member _.``GET order returns 404 when not found`` () = task {
+        let! response = client.GetAsync($"/api/orders/{Guid.NewGuid()}")
+        test <@ response.StatusCode = HttpStatusCode.NotFound @>
+    }
+```
+
+## Test Organization
+
+```
+tests/
+  MyApp.Tests/
+    Unit/
+      OrderServiceTests.fs
+      PaymentServiceTests.fs
+    Integration/
+      OrderApiTests.fs
+      OrderRepositoryTests.fs
+    Properties/
+      OrderPropertyTests.fs
+    Helpers/
+      TestData.fs
+      TestDeps.fs
+```
+
+## Common Anti-Patterns
+
+| Anti-Pattern | Fix |
+|---|---|
+| Testing implementation details | Test behavior and outcomes |
+| Mutable shared test state | Fresh state per test |
+| `Thread.Sleep` in async tests | Use `Task.Delay` with timeout, or polling helpers |
+| Asserting on `sprintf` output | Assert on typed values and pattern matches |
+| Ignoring `CancellationToken` | Always pass and verify cancellation |
+| Skipping property-based tests | Use FsCheck for any function with clear invariants |
+
+## Related Skills
+
+- `dotnet-patterns` - Idiomatic .NET patterns, dependency injection, and architecture
+- `csharp-testing` - C# testing patterns (shared infrastructure like WebApplicationFactory and Testcontainers applies to F# too)
+
+## Running Tests
+
+```bash
+# Run all tests
+dotnet test
+
+# Run with coverage
+dotnet test --collect:"XPlat Code Coverage"
+
+# Run specific project
+dotnet test tests/MyApp.Tests/
+
+# Filter by test name
+dotnet test --filter "FullyQualifiedName~OrderService"
+
+# Watch mode during development
+dotnet watch test --project tests/MyApp.Tests/
+```

package/src/skills/ios-icon-gen/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: ios-icon-gen
+description: Generate iOS app icons as PNG imagesets for Xcode asset catalogs from SF Symbols (5000+ Apple-native) or Iconify API (275k+ open source icons from 200+ collections). Use when generating icons, creating icon assets, adding icons to asset catalog, or searching for icons for iOS projects.
+origin: community
+---
+
+# iOS Icon Generator
+
+Generate PNG icon imagesets for Xcode asset catalogs from two sources.
+
+## When to Activate
+
+- Generating icon assets for an iOS/macOS Xcode project
+- Searching for icons across open source collections
+- Creating PNG imagesets (1x, 2x, 3x) for asset catalogs
+- Replacing placeholder icons with production-quality assets
+- Matching existing icon styles in an Xcode project
+
+## Core Principles
+
+### 1. Two Sources, One Output Format
+Both sources produce identical Xcode-compatible imagesets. Choose based on need:
+
+| Source | Icons | Requires | Best for |
+|--------|-------|----------|----------|
+| **Iconify API** | 275,000+ from 200+ collections | Internet | Wide selection, specific styles, open source icons |
+| **SF Symbols** | 5,000+ Apple symbols | macOS only | Apple-native style, offline use |
+
+### 2. Always Match Existing Style
+Before generating, check the project's existing icons for size, color, and weight consistency.
+
+### 3. Output Structure
+Both methods produce a complete Xcode imageset:
+
+```
+<output-dir>/<asset-name>.imageset/
+  Contents.json
+  <asset-name>.png        # 1x (68px default)
+  <asset-name>@2x.png     # 2x (136px default)
+  <asset-name>@3x.png     # 3x (204px default)
+```
+
+## Examples
+
+### Step 1: Assess Requirements
+
+Determine icon needs: what the icon represents, preferred style, target color, and size.
+
+If the project already has icons, check existing style:
+```bash
+# Check dimensions of existing icon
+sips -g pixelWidth -g pixelHeight path/to/existing@2x.png
+```
+
+### Step 2: Search for Icons
+
+**Iconify API (recommended for wide selection):**
+```bash
+# Search all collections
+$SKILL_DIR/scripts/iconify_gen.sh search "receipt"
+
+# Search within a specific collection
+$SKILL_DIR/scripts/iconify_gen.sh search "business card" --prefix mdi
+
+# List available collections
+$SKILL_DIR/scripts/iconify_gen.sh collections
+```
+
+**SF Symbols (for Apple-native style):**
+Browse the SF Symbols app or reference common names:
+
+| Use Case | Symbol Name |
+|----------|-------------|
+| Document | `doc.text`, `doc.fill` |
+| Receipt | `doc.text.below.ecg`, `receipt` |
+| Person | `person.crop.rectangle`, `person.text.rectangle` |
+| Camera | `camera`, `camera.fill` |
+| Scan | `doc.viewfinder`, `qrcode.viewfinder` |
+| Settings | `gearshape`, `slider.horizontal.3` |
+
+### Step 3: Preview (Optional)
+
+```bash
+# Iconify preview
+$SKILL_DIR/scripts/iconify_gen.sh preview mdi:receipt-text-outline
+```
+
+### Step 4: Generate
+
+**Iconify API:**
+```bash
+# Basic generation
+$SKILL_DIR/scripts/iconify_gen.sh mdi:receipt-text-outline editTool_expenseReport
+
+# Custom color and output location
+$SKILL_DIR/scripts/iconify_gen.sh mdi:receipt-text-outline myIcon --color 007AFF --output ./Assets.xcassets/icons
+```
+
+Options: `--size <pt>` (default: 68), `--color <hex>` (default: 8E8E93), `--output <dir>` (default: /tmp/icons)
+
+**SF Symbols:**
+```bash
+# Basic generation
+swift $SKILL_DIR/scripts/generate_icons.swift doc.text.below.ecg editTool_expenseReport
+
+# Custom color, weight, and output
+swift $SKILL_DIR/scripts/generate_icons.swift person.crop.rectangle myIcon --color 007AFF --weight regular --output ./Assets.xcassets/icons
+```
+
+Options: `--size <pt>` (default: 68), `--color <hex>` (default: 8E8E93), `--weight <name>` (default: thin), `--output <dir>` (default: /tmp/icons)
+
+### Step 5: Verify and Integrate
+
+1. Read the generated @2x PNG to verify visually
+2. Copy to asset catalog if not output there directly:
+   ```bash
+   cp -r /tmp/icons/<name>.imageset path/to/Assets.xcassets/<group>/
+   ```
+3. Build the project to verify Xcode picks up the new assets
+
+## Popular Iconify Collections
+
+| Prefix | Name | Count | Style |
+|--------|------|-------|-------|
+| `mdi` | Material Design Icons | 7400+ | Filled + outline variants |
+| `ph` | Phosphor | 9000+ | 6 weights per icon |
+| `solar` | Solar | 7400+ | Bold, linear, outline |
+| `tabler` | Tabler Icons | 6000+ | Consistent stroke width |
+| `lucide` | Lucide | 1700+ | Clean, minimal |
+| `ri` | Remix Icon | 3100+ | Filled + line variants |
+| `carbon` | Carbon | 2400+ | IBM design language |
+| `heroicons` | HeroIcons | 1200+ | Tailwind CSS companion |
+
+Browse all: <https://icon-sets.iconify.design/>
+
+## Scripts Reference
+
+| Script | Source | Path |
+|--------|--------|------|
+| `iconify_gen.sh` | Iconify API (275k+ icons) | `$SKILL_DIR/scripts/iconify_gen.sh` |
+| `generate_icons.swift` | SF Symbols (5k+ icons) | `$SKILL_DIR/scripts/generate_icons.swift` |
+
+## Best Practices
+
+- **Search before generating** -- browse available icons to find the best match
+- **Match existing project style** -- check dimensions, color, and weight of existing icons before generating new ones
+- **Use Iconify for variety** -- 200+ collections means you can find the exact style you need
+- **Use SF Symbols for Apple consistency** -- they match system UI perfectly
+- **Generate directly to asset catalog** -- use `--output ./Assets.xcassets/icons` to skip manual copying
+- **Verify visually** -- always preview the @2x PNG before committing
+
+## Anti-Patterns
+
+- Generating icons without checking existing project icon style
+- Using default colors when the project has a defined color palette
+- Generating at wrong sizes (check existing icons first)
+- Committing generated icons without visual verification

package/src/skills/ios-icon-gen/scripts/generate_icons.swift

@@ -0,0 +1,258 @@
+#!/usr/bin/env swift
+
+import AppKit
+import Foundation
+
+// MARK: - Configuration
+
+struct IconSpec {
+    let symbolName: String
+    let assetName: String
+    let baseSize: CGFloat
+    let color: NSColor
+    let weight: NSFont.Weight
+}
+
+func parseColor(_ hex: String) -> NSColor {
+    var hex = hex.trimmingCharacters(in: .whitespacesAndNewlines)
+    if hex.hasPrefix("#") { hex.removeFirst() }
+    guard hex.count == 6, let value = UInt64(hex, radix: 16) else {
+        return NSColor(red: 142/255, green: 142/255, blue: 147/255, alpha: 1.0)
+    }
+    return NSColor(
+        red: CGFloat((value >> 16) & 0xFF) / 255,
+        green: CGFloat((value >> 8) & 0xFF) / 255,
+        blue: CGFloat(value & 0xFF) / 255,
+        alpha: 1.0
+    )
+}
+
+func parseWeight(_ name: String) -> NSFont.Weight {
+    switch name.lowercased() {
+    case "ultralight": return .ultraLight
+    case "thin": return .thin
+    case "light": return .light
+    case "regular": return .regular
+    case "medium": return .medium
+    case "semibold": return .semibold
+    case "bold": return .bold
+    case "heavy": return .heavy
+    case "black": return .black
+    default: return .thin
+    }
+}
+
+// MARK: - Generation
+
+enum IconError: Error, CustomStringConvertible {
+    case directoryCreation(String)
+    case symbolNotFound(String)
+    case configurationFailed(String)
+    case pngCreation(String)
+    case fileWrite(String)
+
+    var description: String {
+        switch self {
+        case .directoryCreation(let msg): return msg
+        case .symbolNotFound(let msg): return msg
+        case .configurationFailed(let msg): return msg
+        case .pngCreation(let msg): return msg
+        case .fileWrite(let msg): return msg
+        }
+    }
+}
+
+func generateIcon(_ spec: IconSpec, outputDir: String) throws {
+    let dir = "\(outputDir)/\(spec.assetName).imageset"
+    do {
+        try FileManager.default.createDirectory(atPath: dir, withIntermediateDirectories: true)
+    } catch {
+        throw IconError.directoryCreation("Could not create output directory '\(dir)': \(error.localizedDescription)")
+    }
+
+    let scales: [(suffix: String, multiplier: CGFloat)] = [("", 1), ("@2x", 2), ("@3x", 3)]
+
+    for scale in scales {
+        let pixelSize = spec.baseSize * scale.multiplier
+        let imageSize = NSSize(width: pixelSize, height: pixelSize)
+
+        let config = NSImage.SymbolConfiguration(
+            pointSize: pixelSize * 0.40,
+            weight: spec.weight,
+            scale: .large
+        )
+
+        guard let symbol = NSImage(systemSymbolName: spec.symbolName, accessibilityDescription: nil) else {
+            throw IconError.symbolNotFound("SF Symbol '\(spec.symbolName)' not found. Run 'SF Symbols' app to browse available names.")
+        }
+
+        guard let configured = symbol.withSymbolConfiguration(config) else {
+            throw IconError.configurationFailed("Could not apply symbol configuration to '\(spec.symbolName)'")
+        }
+
+        let image = NSImage(size: imageSize, flipped: false) { rect in
+            let symSize = configured.size
+            let x = (rect.width - symSize.width) / 2
+            let y = (rect.height - symSize.height) / 2
+            let drawRect = NSRect(x: x, y: y, width: symSize.width, height: symSize.height)
+
+            let tinted = NSImage(size: symSize, flipped: false) { tintRect in
+                configured.draw(in: tintRect)
+                spec.color.set()
+                tintRect.fill(using: .sourceAtop)
+                return true
+            }
+
+            tinted.draw(in: drawRect, from: .zero, operation: .sourceOver, fraction: 1.0)
+            return true
+        }
+
+        guard let tiffData = image.tiffRepresentation,
+              let bitmap = NSBitmapImageRep(data: tiffData),
+              let pngData = bitmap.representation(using: .png, properties: [:]) else {
+            throw IconError.pngCreation("Failed to create PNG for \(spec.assetName)\(scale.suffix)")
+        }
+
+        let fileName = "\(spec.assetName)\(scale.suffix).png"
+        do {
+            try pngData.write(to: URL(fileURLWithPath: "\(dir)/\(fileName)"))
+        } catch {
+            throw IconError.fileWrite("Failed to write \(fileName): \(error.localizedDescription)")
+        }
+        print("  \(fileName) (\(Int(pixelSize))x\(Int(pixelSize)))")
+    }
+
+    // Write Contents.json
+    let json = """
+    {
+      "images" : [
+        {
+          "filename" : "\(spec.assetName).png",
+          "idiom" : "universal",
+          "scale" : "1x"
+        },
+        {
+          "filename" : "\(spec.assetName)@2x.png",
+          "idiom" : "universal",
+          "scale" : "2x"
+        },
+        {
+          "filename" : "\(spec.assetName)@3x.png",
+          "idiom" : "universal",
+          "scale" : "3x"
+        }
+      ],
+      "info" : {
+        "author" : "xcode",
+        "version" : 1
+      }
+    }
+    """
+    do {
+        try json.write(toFile: "\(dir)/Contents.json", atomically: true, encoding: .utf8)
+    } catch {
+        throw IconError.fileWrite("Failed to write Contents.json: \(error.localizedDescription)")
+    }
+}
+
+func requireOptionValue(_ args: [String], at index: Int, flag: String) -> String {
+    guard index < args.count else {
+        fputs("ERROR: Missing value for \(flag)\n", stderr)
+        exit(1)
+    }
+    let value = args[index]
+    if value.hasPrefix("--") {
+        fputs("ERROR: Missing value for \(flag)\n", stderr)
+        exit(1)
+    }
+    return value
+}
+
+// MARK: - CLI
+
+let args = CommandLine.arguments
+
+if args.count < 3 || args.contains("--help") || args.contains("-h") {
+    print("""
+    Usage: generate_icons.swift <sf-symbol-name> <asset-name> [options]
+
+    Options:
+      --size <pt>       Base size in points (default: 68)
+      --color <hex>     Color hex code (default: 8E8E93)
+      --weight <name>   Font weight: ultralight|thin|light|regular|medium|semibold|bold|heavy|black (default: thin)
+      --output <dir>    Output directory (default: /tmp/icons)
+
+    Examples:
+      generate_icons.swift doc.text.below.ecg editTool_expenseReport
+      generate_icons.swift person.crop.rectangle editTool_businessCard --color 007AFF --weight regular
+      generate_icons.swift receipt myReceipt --size 48 --output ./Assets.xcassets/icons
+
+    Browse SF Symbol names: open the SF Symbols app (free from Apple) or https://developer.apple.com/sf-symbols/
+    """)
+    exit(0)
+}
+
+let symbolName = args[1]
+let assetName = args[2]
+
+var baseSize: CGFloat = 68
+var colorHex = "8E8E93"
+var weightName = "thin"
+var outputDir = "/tmp/icons"
+
+var i = 3
+while i < args.count {
+    switch args[i] {
+    case "--size":
+        let raw = requireOptionValue(args, at: i + 1, flag: "--size")
+        guard let size = Double(raw), size > 0 else {
+            fputs("ERROR: --size must be a positive number\n", stderr)
+            exit(1)
+        }
+        baseSize = CGFloat(size)
+        i += 2
+        continue
+    case "--color":
+        colorHex = requireOptionValue(args, at: i + 1, flag: "--color")
+        let stripped = colorHex.hasPrefix("#") ? String(colorHex.dropFirst()) : colorHex
+        guard stripped.count == 6, UInt64(stripped, radix: 16) != nil else {
+            fputs("ERROR: --color must be a 6-digit hex code (e.g. 007AFF)\n", stderr)
+            exit(1)
+        }
+        i += 2
+        continue
+    case "--weight":
+        weightName = requireOptionValue(args, at: i + 1, flag: "--weight")
+        let validWeights = ["ultralight", "thin", "light", "regular", "medium", "semibold", "bold", "heavy", "black"]
+        guard validWeights.contains(weightName.lowercased()) else {
+            fputs("ERROR: --weight must be one of: \(validWeights.joined(separator: ", "))\n", stderr)
+            exit(1)
+        }
+        i += 2
+        continue
+    case "--output":
+        outputDir = requireOptionValue(args, at: i + 1, flag: "--output")
+        i += 2
+        continue
+    default:
+        fputs("WARNING: Unknown option \(args[i])\n", stderr)
+    }
+    i += 1
+}
+
+let spec = IconSpec(
+    symbolName: symbolName,
+    assetName: assetName,
+    baseSize: baseSize,
+    color: parseColor(colorHex),
+    weight: parseWeight(weightName)
+)
+
+print("Generating \(assetName) from SF Symbol '\(symbolName)':")
+do {
+    try generateIcon(spec, outputDir: outputDir)
+    print("Output: \(outputDir)/\(assetName).imageset/")
+} catch {
+    fputs("ERROR: \(error)\n", stderr)
+    exit(1)
+}