claudecode-omc 5.6.7 → 5.6.8

package/.local/skills/swiftui-expert-skill/scripts/record_trace.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+"""Record an Xcode Instruments .trace file via `xctrace record`.
+
+Three modes:
+  (default)          Start a recording. Stops on Ctrl+C, stop-file, or time limit.
+  --list-devices     Enumerate connected devices + simulators as JSON.
+  --list-templates   Enumerate available Instruments templates as JSON.
+
+Attach vs launch vs all-processes is mutually exclusive and passed straight
+through to xctrace. The default template is "SwiftUI" (matches the
+SwiftUI template in Xcode 26+ — change with --template).
+
+Manual stop options, most to least automated:
+  * Send SIGINT (Ctrl+C) to this script — forwarded to xctrace, which
+    finalises the trace before exiting.
+  * Pass --stop-file PATH; when that file appears on disk, this script
+    sends SIGINT to xctrace. Useful for `Bash run_in_background`
+    workflows where there's no interactive terminal.
+  * Pass --time-limit 30s / 5m / etc. — xctrace stops itself.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import signal
+import subprocess
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Record an Instruments .trace file.")
+    list_mode = parser.add_mutually_exclusive_group()
+    list_mode.add_argument("--list-devices", action="store_true",
+                           help="List devices and simulators as JSON, then exit.")
+    list_mode.add_argument("--list-templates", action="store_true",
+                           help="List template names as JSON, then exit.")
+
+    parser.add_argument("--template", default="SwiftUI",
+                        help="Template name (default: SwiftUI).")
+    parser.add_argument("--device", default=None,
+                        help="Device name or UDID. Defaults to the host.")
+    parser.add_argument("--output", type=Path, default=None,
+                        help="Output .trace path. Defaults to ./<template>-<timestamp>.trace.")
+    parser.add_argument("--time-limit", default=None,
+                        help="Cap recording duration (e.g. 30s, 5m, 1h). Optional.")
+    parser.add_argument("--stop-file", type=Path, default=None,
+                        help="When this path appears on disk, stop the recording.")
+    parser.add_argument("--env", action="append", default=[],
+                        metavar="KEY=VALUE",
+                        help="Env var for the launched process. Can repeat. Launch mode only.")
+    parser.add_argument("--instrument", action="append", default=[],
+                        help="Extra --instrument flag passthrough (can repeat).")
+    parser.add_argument("--run-name", default=None)
+
+    target = parser.add_mutually_exclusive_group()
+    target.add_argument("--launch", metavar="APP",
+                        help="Launch this .app path and record it.")
+    target.add_argument("--attach", metavar="PID_OR_NAME",
+                        help="Attach to a running process by pid or name.")
+    target.add_argument("--all-processes", action="store_true",
+                        help="Record every process (system-wide).")
+
+    args = parser.parse_args(argv)
+
+    if args.list_devices:
+        _print_devices()
+        return 0
+    if args.list_templates:
+        _print_templates()
+        return 0
+
+    if not (args.launch or args.attach or args.all_processes):
+        print("error: need one of --launch, --attach, or --all-processes.",
+              file=sys.stderr)
+        return 2
+
+    if args.env and not args.launch:
+        # xctrace silently ignores --env outside launch mode; surfacing this
+        # explicitly saves agents a confusing "why didn't my env var apply?".
+        print("error: --env only applies to --launch; remove it or switch target mode.",
+              file=sys.stderr)
+        return 2
+
+    output = args.output or Path.cwd() / _default_trace_name(args.template)
+    if output.exists():
+        print(f"error: output already exists: {output}", file=sys.stderr)
+        return 2
+
+    cmd = _build_xctrace_cmd(args, output)
+
+    # Tell the user (and an agent reading stdout) what's happening + how to stop.
+    print("[record] starting xctrace record", flush=True)
+    print(f"[record]   template: {args.template}", flush=True)
+    print(f"[record]   device:   {args.device or '(host)'}", flush=True)
+    print(f"[record]   target:   {_describe_target(args)}", flush=True)
+    print(f"[record]   output:   {output}", flush=True)
+    stop_hints = ["Ctrl+C"]
+    if args.stop_file:
+        stop_hints.append(f"`touch {args.stop_file}`")
+    if args.time_limit:
+        stop_hints.append(f"after {args.time_limit}")
+    print(f"[record] stop via: {', '.join(stop_hints)}", flush=True)
+    print(f"[record] cmd: {' '.join(_shell_quote(c) for c in cmd)}", flush=True)
+
+    # Start xctrace in its own process group so we can signal cleanly.
+    proc = subprocess.Popen(cmd, start_new_session=True)
+
+    try:
+        _wait_with_stop(proc, args.stop_file)
+    except KeyboardInterrupt:
+        _forward_sigint(proc)
+
+    # Give xctrace up to 60s to finalise after SIGINT — large traces take time.
+    try:
+        rc = proc.wait(timeout=60)
+    except subprocess.TimeoutExpired:
+        print("[record] xctrace did not exit within 60s after stop; killing.",
+              file=sys.stderr)
+        proc.kill()
+        rc = proc.wait()
+
+    if output.exists():
+        print(f"[record] done. trace written: {output}", flush=True)
+    else:
+        print("[record] done but output file not found — did xctrace error?",
+              file=sys.stderr)
+        return rc or 1
+    return rc
+
+
+def _build_xctrace_cmd(args, output: Path) -> list[str]:
+    cmd = ["xctrace", "record", "--template", args.template, "--output", str(output)]
+    if args.device:
+        cmd += ["--device", args.device]
+    if args.time_limit:
+        cmd += ["--time-limit", args.time_limit]
+    if args.run_name:
+        cmd += ["--run-name", args.run_name]
+    for inst in args.instrument:
+        cmd += ["--instrument", inst]
+    for env in args.env:
+        cmd += ["--env", env]
+    # Target must come last — --launch consumes the remainder.
+    if args.attach:
+        cmd += ["--attach", args.attach]
+    elif args.all_processes:
+        cmd += ["--all-processes"]
+    elif args.launch:
+        cmd += ["--launch", "--", args.launch]
+    return cmd
+
+
+def _describe_target(args) -> str:
+    if args.launch:
+        return f"launch {args.launch}"
+    if args.attach:
+        return f"attach {args.attach}"
+    if args.all_processes:
+        return "all processes"
+    return "(none)"
+
+
+def _default_trace_name(template: str) -> str:
+    safe = re.sub(r"[^A-Za-z0-9]+", "-", template).strip("-").lower() or "trace"
+    ts = datetime.now().strftime("%Y%m%d-%H%M%S")
+    return f"{safe}-{ts}.trace"
+
+
+def _wait_with_stop(proc: subprocess.Popen, stop_file: Path | None) -> None:
+    """Poll until xctrace exits or stop_file appears; then send SIGINT."""
+    while True:
+        rc = proc.poll()
+        if rc is not None:
+            return
+        if stop_file and stop_file.exists():
+            print(f"[record] stop-file detected ({stop_file}); stopping xctrace.",
+                  flush=True)
+            _forward_sigint(proc)
+            return
+        time.sleep(0.5)
+
+
+def _forward_sigint(proc: subprocess.Popen) -> None:
+    try:
+        # Signal the whole group so child instruments tools also get SIGINT.
+        os.killpg(os.getpgid(proc.pid), signal.SIGINT)
+    except ProcessLookupError:
+        pass
+
+
+def _print_devices() -> None:
+    out = subprocess.run(
+        ["xctrace", "list", "devices"], capture_output=True, text=True, check=True
+    ).stdout
+    devices: list[dict] = []
+    section = None
+    # Device lines end with "(UDID)"; real iOS devices also have "(OS version)"
+    # before the UDID. The host (macOS) line has only "(UDID)".
+    line_re = re.compile(r"^(.+?)(?:\s+\(([^()]+)\))?\s+\(([0-9A-Fa-f-]{20,})\)\s*$")
+    for line in out.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if stripped.startswith("==") and stripped.endswith("=="):
+            section = stripped.strip("= ").strip().lower()
+            continue
+        m = line_re.match(stripped)
+        if not m:
+            continue
+        name, os_ver, udid = m.group(1).strip(), m.group(2), m.group(3)
+        devices.append({
+            "kind": section or "unknown",
+            "name": name,
+            "os": os_ver,
+            "udid": udid,
+        })
+    print(json.dumps({"devices": devices}, indent=2))
+
+
+def _print_templates() -> None:
+    out = subprocess.run(
+        ["xctrace", "list", "templates"], capture_output=True, text=True, check=True
+    ).stdout
+    groups: dict[str, list[str]] = {}
+    section = "unknown"
+    for line in out.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        if stripped.startswith("==") and stripped.endswith("=="):
+            section = stripped.strip("= ").strip().lower()
+            groups.setdefault(section, [])
+            continue
+        groups.setdefault(section, []).append(stripped)
+    # Flat convenience list + structured by section.
+    flat = [name for items in groups.values() for name in items]
+    print(json.dumps({"templates": flat, "by_section": groups}, indent=2))
+
+
+def _shell_quote(s: str) -> str:
+    if re.match(r"^[A-Za-z0-9_./:=@-]+$", s):
+        return s
+    return "'" + s.replace("'", "'\\''") + "'"
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.local/skills/swiftui-liquid-glass/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: swiftui-liquid-glass
+description: Implement, review, or improve SwiftUI features using the iOS 26+ Liquid Glass API. Use when asked to adopt Liquid Glass in new SwiftUI UI, refactor an existing feature to Liquid Glass, or review Liquid Glass usage for correctness, performance, and design alignment.
+---
+
+# SwiftUI Liquid Glass
+
+## Overview
+Use this skill to build or review SwiftUI features that fully align with the iOS 26+ Liquid Glass API. Prioritize native APIs (`glassEffect`, `GlassEffectContainer`, glass button styles) and Apple design guidance. Keep usage consistent, interactive where needed, and performance aware.
+
+## Workflow Decision Tree
+Choose the path that matches the request:
+
+### 1) Review an existing feature
+- Inspect where Liquid Glass should be used and where it should not.
+- Verify correct modifier order, shape usage, and container placement.
+- Check for iOS 26+ availability handling and sensible fallbacks.
+
+### 2) Improve a feature using Liquid Glass
+- Identify target components for glass treatment (surfaces, chips, buttons, cards).
+- Refactor to use `GlassEffectContainer` where multiple glass elements appear.
+- Introduce interactive glass only for tappable or focusable elements.
+
+### 3) Implement a new feature using Liquid Glass
+- Design the glass surfaces and interactions first (shape, prominence, grouping).
+- Add glass modifiers after layout/appearance modifiers.
+- Add morphing transitions only when the view hierarchy changes with animation.
+
+## Core Guidelines
+- Prefer native Liquid Glass APIs over custom blurs.
+- Use `GlassEffectContainer` when multiple glass elements coexist.
+- Apply `.glassEffect(...)` after layout and visual modifiers.
+- Use `.interactive()` for elements that respond to touch/pointer.
+- Keep shapes consistent across related elements for a cohesive look.
+- Gate with `#available(iOS 26, *)` and provide a non-glass fallback.
+
+## Review Checklist
+- **Availability**: `#available(iOS 26, *)` present with fallback UI.
+- **Composition**: Multiple glass views wrapped in `GlassEffectContainer`.
+- **Modifier order**: `glassEffect` applied after layout/appearance modifiers.
+- **Interactivity**: `interactive()` only where user interaction exists.
+- **Transitions**: `glassEffectID` used with `@Namespace` for morphing.
+- **Consistency**: Shapes, tinting, and spacing align across the feature.
+
+## Implementation Checklist
+- Define target elements and desired glass prominence.
+- Wrap grouped glass elements in `GlassEffectContainer` and tune spacing.
+- Use `.glassEffect(.regular.tint(...).interactive(), in: .rect(cornerRadius: ...))` as needed.
+- Use `.buttonStyle(.glass)` / `.buttonStyle(.glassProminent)` for actions.
+- Add morphing transitions with `glassEffectID` when hierarchy changes.
+- Provide fallback materials and visuals for earlier iOS versions.
+
+## Quick Snippets
+Use these patterns directly and tailor shapes/tints/spacing.
+
+```swift
+if #available(iOS 26, *) {
+    Text("Hello")
+        .padding()
+        .glassEffect(.regular.interactive(), in: .rect(cornerRadius: 16))
+} else {
+    Text("Hello")
+        .padding()
+        .background(.ultraThinMaterial, in: RoundedRectangle(cornerRadius: 16))
+}
+```
+
+```swift
+GlassEffectContainer(spacing: 24) {
+    HStack(spacing: 24) {
+        Image(systemName: "scribble.variable")
+            .frame(width: 72, height: 72)
+            .font(.system(size: 32))
+            .glassEffect()
+        Image(systemName: "eraser.fill")
+            .frame(width: 72, height: 72)
+            .font(.system(size: 32))
+            .glassEffect()
+    }
+}
+```
+
+```swift
+Button("Confirm") { }
+    .buttonStyle(.glassProminent)
+```
+
+## Resources
+- Reference guide: `references/liquid-glass.md`
+- Prefer Apple docs for up-to-date API details.

package/.local/skills/swiftui-liquid-glass/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "SwiftUI Liquid Glass"
+  short_description: "Build SwiftUI Liquid Glass features"
+  default_prompt: "Use $swiftui-liquid-glass to implement or review a SwiftUI feature using Liquid Glass APIs."

package/.local/skills/swiftui-liquid-glass/references/liquid-glass.md

@@ -0,0 +1,280 @@
+# Implementing Liquid Glass Design in SwiftUI
+
+## Overview
+
+Liquid Glass is a dynamic material introduced in iOS that combines the optical properties of glass with a sense of fluidity. It blurs content behind it, reflects color and light from surrounding content, and reacts to touch and pointer interactions in real time. This guide covers how to implement and customize Liquid Glass effects in SwiftUI applications. You should always seek guides on Liquid Glass when asked for help adopting new Apple design.
+
+Key features of Liquid Glass:
+- Blurs content behind the material
+- Reflects color and light from surrounding content
+- Reacts to touch and pointer interactions
+- Can morph between shapes during transitions
+- Available for standard and custom components
+
+## Basic Implementation
+
+### Adding Liquid Glass to a View
+
+The simplest way to add Liquid Glass to a view is using the `glassEffect()` modifier:
+
+```swift
+Text("Hello, World!")
+    .font(.title)
+    .padding()
+    .glassEffect()
+```
+
+By default, this applies the regular variant of Glass within a Capsule shape behind the view's content.
+
+### Customizing the Shape
+
+You can specify a different shape for the Liquid Glass effect:
+
+```swift
+Text("Hello, World!")
+    .font(.title)
+    .padding()
+    .glassEffect(in: .rect(cornerRadius: 16.0))
+```
+
+Common shape options:
+- `.capsule` (default)
+- `.rect(cornerRadius: CGFloat)`
+- `.circle`
+
+## Customizing Liquid Glass Effects
+
+### Glass Variants and Properties
+
+You can customize the Liquid Glass effect by configuring the `Glass` structure:
+
+```swift
+Text("Hello, World!")
+    .font(.title)
+    .padding()
+    .glassEffect(.regular.tint(.orange).interactive())
+```
+
+Key customization options:
+- `.regular` - Standard glass effect
+- `.tint(Color)` - Add a color tint to suggest prominence
+- `.interactive(Bool)` - Make the glass react to touch and pointer interactions
+
+### Making Interactive Glass
+
+To make Liquid Glass react to touch and pointer interactions:
+
+```swift
+Text("Hello, World!")
+    .font(.title)
+    .padding()
+    .glassEffect(.regular.interactive(true))
+```
+
+Or more concisely:
+
+```swift
+Text("Hello, World!")
+    .font(.title)
+    .padding()
+    .glassEffect(.regular.interactive())
+```
+
+## Working with Multiple Glass Effects
+
+### Using GlassEffectContainer
+
+When applying Liquid Glass effects to multiple views, use `GlassEffectContainer` for better rendering performance and to enable blending and morphing effects:
+
+```swift
+GlassEffectContainer(spacing: 40.0) {
+    HStack(spacing: 40.0) {
+        Image(systemName: "scribble.variable")
+            .frame(width: 80.0, height: 80.0)
+            .font(.system(size: 36))
+            .glassEffect()
+
+        Image(systemName: "eraser.fill")
+            .frame(width: 80.0, height: 80.0)
+            .font(.system(size: 36))
+            .glassEffect()
+    }
+}
+```
+
+The `spacing` parameter controls how the Liquid Glass effects interact with each other:
+- Smaller spacing: Views need to be closer to merge effects
+- Larger spacing: Effects merge at greater distances
+
+### Uniting Multiple Glass Effects
+
+To combine multiple views into a single Liquid Glass effect, use the `glassEffectUnion` modifier:
+
+```swift
+@Namespace private var namespace
+
+// Later in your view:
+GlassEffectContainer(spacing: 20.0) {
+    HStack(spacing: 20.0) {
+        ForEach(symbolSet.indices, id: \.self) { item in
+            Image(systemName: symbolSet[item])
+                .frame(width: 80.0, height: 80.0)
+                .font(.system(size: 36))
+                .glassEffect()
+                .glassEffectUnion(id: item < 2 ? "1" : "2", namespace: namespace)
+        }
+    }
+}
+```
+
+This is useful when creating views dynamically or with views that live outside of an HStack or VStack.
+
+## Morphing Effects and Transitions
+
+### Creating Morphing Transitions
+
+To create morphing effects during transitions between views with Liquid Glass:
+
+1. Create a namespace using the `@Namespace` property wrapper
+2. Associate each Liquid Glass effect with a unique identifier using `glassEffectID`
+3. Use animations when changing the view hierarchy
+
+```swift
+@State private var isExpanded: Bool = false
+@Namespace private var namespace
+
+var body: some View {
+    GlassEffectContainer(spacing: 40.0) {
+        HStack(spacing: 40.0) {
+            Image(systemName: "scribble.variable")
+                .frame(width: 80.0, height: 80.0)
+                .font(.system(size: 36))
+                .glassEffect()
+                .glassEffectID("pencil", in: namespace)
+
+            if isExpanded {
+                Image(systemName: "eraser.fill")
+                    .frame(width: 80.0, height: 80.0)
+                    .font(.system(size: 36))
+                    .glassEffect()
+                    .glassEffectID("eraser", in: namespace)
+            }
+        }
+    }
+
+    Button("Toggle") {
+        withAnimation {
+            isExpanded.toggle()
+        }
+    }
+    .buttonStyle(.glass)
+}
+```
+
+The morphing effect occurs when views with Liquid Glass appear or disappear due to view hierarchy changes.
+
+## Button Styling with Liquid Glass
+
+### Glass Button Style
+
+SwiftUI provides built-in button styles for Liquid Glass:
+
+```swift
+Button("Click Me") {
+    // Action
+}
+.buttonStyle(.glass)
+```
+
+### Glass Prominent Button Style
+
+For a more prominent glass button:
+
+```swift
+Button("Important Action") {
+    // Action
+}
+.buttonStyle(.glassProminent)
+```
+
+## Advanced Techniques
+
+### Background Extension Effect
+
+To stretch content behind a sidebar or inspector with the background extension effect:
+
+```swift
+NavigationSplitView {
+    // Sidebar content
+} detail: {
+    // Detail content
+        .background {
+            // Background content that extends under the sidebar
+        }
+}
+```
+
+### Extending Horizontal Scrolling Under Sidebar
+
+To extend horizontal scroll views under a sidebar or inspector:
+
+```swift
+ScrollView(.horizontal) {
+    // Scrollable content
+}
+.scrollExtensionMode(.underSidebar)
+```
+
+## Best Practices
+
+1. **Container Usage**: Always use `GlassEffectContainer` when applying Liquid Glass to multiple views for better performance and morphing effects.
+
+2. **Effect Order**: Apply the `.glassEffect()` modifier after other modifiers that affect the appearance of the view.
+
+3. **Spacing Consideration**: Carefully choose spacing values in containers to control how and when glass effects merge.
+
+4. **Animation**: Use animations when changing view hierarchies to enable smooth morphing transitions.
+
+5. **Interactivity**: Add `.interactive()` to glass effects that should respond to user interaction.
+
+6. **Consistent Design**: Maintain consistent shapes and styles across your app for a cohesive look and feel.
+
+## Example: Custom Badge with Liquid Glass
+
+```swift
+struct BadgeView: View {
+    let symbol: String
+    let color: Color
+
+    var body: some View {
+        ZStack {
+            Image(systemName: "hexagon.fill")
+                .foregroundColor(color)
+                .font(.system(size: 50))
+
+            Image(systemName: symbol)
+                .foregroundColor(.white)
+                .font(.system(size: 30))
+        }
+        .glassEffect(.regular, in: .rect(cornerRadius: 16))
+    }
+}
+
+// Usage:
+GlassEffectContainer(spacing: 20) {
+    HStack(spacing: 20) {
+        BadgeView(symbol: "star.fill", color: .blue)
+        BadgeView(symbol: "heart.fill", color: .red)
+        BadgeView(symbol: "leaf.fill", color: .green)
+    }
+}
+```
+
+## References
+
+- [Applying Liquid Glass to custom views](https://developer.apple.com/documentation/SwiftUI/Applying-Liquid-Glass-to-custom-views)
+- [Landmarks: Building an app with Liquid Glass](https://developer.apple.com/documentation/SwiftUI/Landmarks-Building-an-app-with-Liquid-Glass)
+- [SwiftUI View.glassEffect(_:in:isEnabled:)](https://developer.apple.com/documentation/SwiftUI/View/glassEffect(_:in:isEnabled:))
+- [SwiftUI GlassEffectContainer](https://developer.apple.com/documentation/SwiftUI/GlassEffectContainer)
+- [SwiftUI GlassEffectTransition](https://developer.apple.com/documentation/SwiftUI/GlassEffectTransition)
+- [SwiftUI GlassButtonStyle](https://developer.apple.com/documentation/SwiftUI/GlassButtonStyle)