zugzbot 1.0.20 → 1.0.22

package/.opencode/oh-my-design/.agents/skills/google-analytics/scripts/ga_client.py

@@ -1,345 +0,0 @@
-#!/usr/bin/env python3
-"""
-Google Analytics 4 Data API Client
-
-Fetches analytics data from Google Analytics 4 using the Data API.
-Authentication uses service account credentials from environment variables.
-
-Usage:
-    python ga_client.py --days 30 --metrics sessions,users
-    python ga_client.py --start 2026-01-01 --end 2026-01-31 --dimensions country
-    python ga_client.py --days 7 --metrics sessions --dimensions pagePath --limit 10
-
-Environment Variables:
-    GOOGLE_ANALYTICS_PROPERTY_ID: GA4 property ID (required)
-    GOOGLE_APPLICATION_CREDENTIALS: Path to service account JSON (required)
-"""
-
-import os
-import sys
-import json
-import argparse
-from datetime import datetime, timedelta
-from typing import List, Dict, Optional
-
-try:
-    from google.analytics.data_v1beta import BetaAnalyticsDataClient
-    from google.analytics.data_v1beta.types import (
-        DateRange,
-        Dimension,
-        Metric,
-        RunReportRequest,
-        OrderBy,
-        FilterExpression,
-        Filter,
-    )
-    from dotenv import load_dotenv
-except ImportError as e:
-    print(f"Error: Required package not installed: {e}", file=sys.stderr)
-    print("Install with: pip install google-analytics-data python-dotenv", file=sys.stderr)
-    sys.exit(1)
-
-
-class GoogleAnalyticsClient:
-    """Client for interacting with Google Analytics 4 Data API."""
-
-    def __init__(self):
-        """Initialize the client with credentials from environment."""
-        load_dotenv()  # Load from .env file if present
-
-        self.property_id = os.environ.get("GOOGLE_ANALYTICS_PROPERTY_ID")
-        if not self.property_id:
-            raise ValueError(
-                "GOOGLE_ANALYTICS_PROPERTY_ID environment variable not set. "
-                "Find your property ID in GA4: Admin > Property Settings"
-            )
-
-        credentials_path = os.environ.get("GOOGLE_APPLICATION_CREDENTIALS")
-        if not credentials_path:
-            raise ValueError(
-                "GOOGLE_APPLICATION_CREDENTIALS environment variable not set. "
-                "Set it to the path of your service account JSON file."
-            )
-
-        if not os.path.exists(credentials_path):
-            raise FileNotFoundError(
-                f"Service account file not found: {credentials_path}"
-            )
-
-        try:
-            self.client = BetaAnalyticsDataClient()
-        except Exception as e:
-            raise RuntimeError(
-                f"Failed to initialize Google Analytics client: {e}\n"
-                "Verify your service account has access to the GA4 property."
-            )
-
-    def run_report(
-        self,
-        start_date: str,
-        end_date: str,
-        metrics: List[str],
-        dimensions: Optional[List[str]] = None,
-        limit: int = 10,
-        order_by: Optional[str] = None,
-        filter_expression: Optional[str] = None,
-    ) -> Dict:
-        """
-        Run a report query against Google Analytics.
-
-        Args:
-            start_date: Start date (YYYY-MM-DD or 'NdaysAgo')
-            end_date: End date (YYYY-MM-DD or 'today'/'yesterday')
-            metrics: List of metric names (e.g., ['sessions', 'users'])
-            dimensions: List of dimension names (e.g., ['country', 'city'])
-            limit: Maximum number of rows to return
-            order_by: Metric or dimension to sort by
-            filter_expression: Filter to apply (dimension_name:value)
-
-        Returns:
-            Dictionary with report data and metadata
-        """
-        # Build request
-        request = RunReportRequest(
-            property=f"properties/{self.property_id}",
-            date_ranges=[DateRange(start_date=start_date, end_date=end_date)],
-            metrics=[Metric(name=m) for m in metrics],
-            dimensions=[Dimension(name=d) for d in (dimensions or [])],
-            limit=limit,
-        )
-
-        # Add ordering
-        if order_by:
-            desc = True
-            if order_by.startswith("+"):
-                desc = False
-                order_by = order_by[1:]
-            elif order_by.startswith("-"):
-                order_by = order_by[1:]
-
-            # Check if it's a metric or dimension
-            if order_by in metrics:
-                request.order_bys = [
-                    OrderBy(metric=OrderBy.MetricOrderBy(metric_name=order_by), desc=desc)
-                ]
-            elif dimensions and order_by in dimensions:
-                request.order_bys = [
-                    OrderBy(
-                        dimension=OrderBy.DimensionOrderBy(dimension_name=order_by),
-                        desc=desc,
-                    )
-                ]
-
-        # Add filter
-        if filter_expression and ":" in filter_expression:
-            field_name, value = filter_expression.split(":", 1)
-            request.dimension_filter = FilterExpression(
-                filter=Filter(
-                    field_name=field_name,
-                    string_filter=Filter.StringFilter(value=value),
-                )
-            )
-
-        try:
-            response = self.client.run_report(request)
-        except Exception as e:
-            raise RuntimeError(f"Failed to run report: {e}")
-
-        # Parse response
-        return self._parse_response(response)
-
-    def _parse_response(self, response) -> Dict:
-        """Parse API response into a structured dictionary."""
-        result = {
-            "dimension_headers": [h.name for h in response.dimension_headers],
-            "metric_headers": [
-                {"name": h.name, "type": h.type_.name} for h in response.metric_headers
-            ],
-            "rows": [],
-            "row_count": response.row_count,
-            "metadata": {},
-        }
-
-        # Add totals if present
-        if response.totals:
-            result["totals"] = [
-                {"value": v.value} for v in response.totals[0].metric_values
-            ]
-
-        # Parse rows
-        for row in response.rows:
-            parsed_row = {
-                "dimensions": {},
-                "metrics": {},
-            }
-
-            # Dimension values
-            for i, value in enumerate(row.dimension_values):
-                dim_name = result["dimension_headers"][i]
-                parsed_row["dimensions"][dim_name] = value.value
-
-            # Metric values
-            for i, value in enumerate(row.metric_values):
-                metric_info = result["metric_headers"][i]
-                metric_name = metric_info["name"]
-                parsed_row["metrics"][metric_name] = value.value
-
-            result["rows"].append(parsed_row)
-
-        return result
-
-
-def parse_date_range(days: Optional[int], start: Optional[str], end: Optional[str]):
-    """Parse date range arguments into start and end dates."""
-    if days:
-        return f"{days}daysAgo", "yesterday"
-    elif start and end:
-        return start, end
-    else:
-        # Default to last 7 days
-        return "7daysAgo", "yesterday"
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Fetch Google Analytics 4 data",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Last 30 days of sessions and users
-  python ga_client.py --days 30 --metrics sessions,users
-
-  # Specific date range with dimensions
-  python ga_client.py --start 2026-01-01 --end 2026-01-31 \\
-      --metrics sessions,bounceRate --dimensions country,city
-
-  # Top pages by views
-  python ga_client.py --days 7 --metrics screenPageViews \\
-      --dimensions pagePath --order-by screenPageViews --limit 20
-
-  # Filter by country
-  python ga_client.py --days 30 --metrics sessions \\
-      --dimensions country --filter "country:United States"
-        """,
-    )
-
-    # Date range arguments
-    date_group = parser.add_mutually_exclusive_group()
-    date_group.add_argument(
-        "--days", type=int, help="Number of days to look back (e.g., 30)"
-    )
-    date_group.add_argument(
-        "--start", help="Start date (YYYY-MM-DD or 'NdaysAgo')"
-    )
-    parser.add_argument("--end", help="End date (YYYY-MM-DD or 'today'/'yesterday')")
-
-    # Query arguments
-    parser.add_argument(
-        "--metrics",
-        required=True,
-        help="Comma-separated list of metrics (e.g., sessions,users,bounceRate)",
-    )
-    parser.add_argument(
-        "--dimensions",
-        help="Comma-separated list of dimensions (e.g., country,city,deviceCategory)",
-    )
-    parser.add_argument(
-        "--limit", type=int, default=10, help="Maximum rows to return (default: 10)"
-    )
-    parser.add_argument(
-        "--order-by",
-        help="Metric or dimension to sort by (prefix with - for desc, + for asc)",
-    )
-    parser.add_argument(
-        "--filter", help="Filter expression (e.g., 'country:United States')"
-    )
-
-    # Output arguments
-    parser.add_argument(
-        "--format",
-        choices=["json", "table"],
-        default="json",
-        help="Output format (default: json)",
-    )
-    parser.add_argument(
-        "--output", help="Output file path (default: stdout)"
-    )
-
-    args = parser.parse_args()
-
-    try:
-        # Initialize client
-        client = GoogleAnalyticsClient()
-
-        # Parse date range
-        start_date, end_date = parse_date_range(args.days, args.start, args.end)
-
-        # Parse metrics and dimensions
-        metrics = [m.strip() for m in args.metrics.split(",")]
-        dimensions = (
-            [d.strip() for d in args.dimensions.split(",")] if args.dimensions else None
-        )
-
-        # Run report
-        result = client.run_report(
-            start_date=start_date,
-            end_date=end_date,
-            metrics=metrics,
-            dimensions=dimensions,
-            limit=args.limit,
-            order_by=args.order_by,
-            filter_expression=args.filter,
-        )
-
-        # Format output
-        if args.format == "json":
-            output = json.dumps(result, indent=2)
-        else:  # table format
-            output = format_as_table(result)
-
-        # Write output
-        if args.output:
-            with open(args.output, "w") as f:
-                f.write(output)
-            print(f"Report saved to {args.output}", file=sys.stderr)
-        else:
-            print(output)
-
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-def format_as_table(result: Dict) -> str:
-    """Format result as a human-readable table."""
-    lines = []
-
-    # Header
-    headers = result["dimension_headers"] + [m["name"] for m in result["metric_headers"]]
-    lines.append(" | ".join(headers))
-    lines.append("-" * (len(" | ".join(headers))))
-
-    # Rows
-    for row in result["rows"]:
-        values = []
-        for dim in result["dimension_headers"]:
-            values.append(row["dimensions"].get(dim, ""))
-        for metric in result["metric_headers"]:
-            values.append(row["metrics"].get(metric["name"], ""))
-        lines.append(" | ".join(values))
-
-    # Totals
-    if "totals" in result:
-        lines.append("-" * (len(" | ".join(headers))))
-        total_values = ["TOTAL"] + [""] * (len(result["dimension_headers"]) - 1)
-        total_values += [t["value"] for t in result["totals"]]
-        lines.append(" | ".join(total_values))
-
-    lines.append("")
-    lines.append(f"Total rows: {result['row_count']}")
-
-    return "\n".join(lines)
-
-
-if __name__ == "__main__":
-    main()

package/.opencode/oh-my-design/.claude/agents/omd-a11y-auditor.md

@@ -1,98 +0,0 @@
----
-name: omd-a11y-auditor
-description: Stage 0 deterministic gate of the eval pipeline. Runs DESIGN.md spec validation, axe-core, lighthouse, and Tier-1 official-DS URL liveness. Pass/fail is binary. Never opinion-based — always tool-output-based.
-tools: Read, Bash, Glob, WebFetch, Write
-model: haiku
-omd_managed: true
----
-
-# omd-a11y-auditor
-
-You are the deterministic gate. You run mechanical checks. You don't opinionate. You either find a violation (with exact tool output) or pass.
-
-## Inputs
-
-- `run_dir`: current `.omd/runs/run-<ts>-<slug>/`
-- `design_md_path`: project DESIGN.md
-- `references_path`: `references-cited.md`
-- `output_path`: `eval/deterministic.json`
-
-## Checks
-
-### Check 1 — DESIGN.md spec validation
-
-Read DESIGN.md. Verify:
-
-- YAML frontmatter present with `omd:` and `brand:`
-- Sections 1-5 present and non-empty (REQUIRED)
-- Sections 6-9 present (RECOMMENDED — warning, not failure)
-- Sections 10-15 present (RECOMMENDED — warning, not failure)
-- §11/12/13 do not contain `[FILL IN]` placeholders if user provided facts in Phase 1 (read `brief.md` to determine)
-
-### Check 2 — Tier-1 official-DS URL liveness
-
-For each URL in `references-cited.md` marked Tier-1, run:
-
-```bash
-curl -s -o /dev/null -w "%{http_code}" -L --max-time 10 "<URL>"
-```
-
-200/301/302 = pass. Other = fail. Record actual code.
-
-### Check 3 — axe-core (if Playwright MCP available)
-
-If `mcp__playwright__*` tools available AND wireframes have a renderable preview:
-
-```bash
-# Requires axe-core npm package — check first
-npx --yes @axe-core/cli@latest <URL> --reporter v2 > eval/axe-output.json 2>&1 || echo "axe-core unavailable"
-```
-
-If unavailable, mark this check as `skipped: "axe-core requires Playwright + rendered HTML"`.
-
-### Check 4 — lighthouse (if available)
-
-```bash
-npx --yes lighthouse <URL> --only-categories=accessibility --output=json --output-path=eval/lighthouse.json --chrome-flags="--headless" 2>/dev/null || echo "lighthouse unavailable"
-```
-
-Pass if accessibility score ≥ 90.
-
-### Check 5 — Wireframe state completeness
-
-For each `wireframes/*.md`, verify the "States" table has all 5 rows (Empty / Loading / Error / Success / Skeleton). Missing any = violation.
-
-### Check 6 — Forbidden-phrase scan
-
-`grep` `components/microcopy.json` for forbidden phrases listed in DESIGN.md §10. Any hit = violation.
-
-## Output
-
-Write `eval/deterministic.json`:
-
-```json
-{
-  "run_id": "run-<ts>-<slug>",
-  "audited_at": "<ISO>",
-  "checks": {
-    "design_md_spec": { "status": "pass|fail|warn", "details": "..." },
-    "tier1_urls": { "status": "...", "results": [...] },
-    "axe_core": { "status": "pass|fail|skipped", "violations": [...] },
-    "lighthouse": { "status": "pass|fail|skipped", "score": 96 },
-    "wireframe_states": { "status": "...", "missing": [...] },
-    "forbidden_phrases": { "status": "...", "hits": [...] }
-  },
-  "verdict": "pass | fail",
-  "critical_failures": [],
-  "warnings": []
-}
-```
-
-`verdict = pass` ONLY if every required check is pass and no critical_failures.
-
-## Hard rules
-
-- You do NOT make opinion calls ("this looks good"). Only tool-output-based.
-- You do NOT skip a check silently. If unavailable, mark `skipped` with reason.
-- You do NOT modify any artifact. Read-only on the run except your own output.
-- If a tool errors, capture stderr verbatim into `details`.

package/.opencode/oh-my-design/.claude/agents/omd-asset-curator.md

@@ -1,99 +0,0 @@
----
-name: omd-asset-curator
-description: Identifies asset needs (photos, video, illustrations, icons) for a design, drafts Pinterest-style reference briefs, and sources free-license fallbacks (Unsplash, Pexels, Lucide, Heroicons, unDraw, Mixkit). Tracks license + attribution. Never violates Pinterest TOS — only lists URLs for user download.
-tools: Read, Write, WebSearch, WebFetch, Bash, Glob
-model: sonnet
-omd_managed: true
----
-
-# omd-asset-curator
-
-You are the asset specialist. Two modes:
-
-## Mode A — Asset Brief (Phase 1.5)
-
-**Inputs:**
-- `brief_path`: `brief.md`
-- `output_path`: `assets/brief.md`
-
-**Action:**
-1. Read brief.md. From journeys + screen list, infer asset needs.
-2. For each asset, emit a YAML block:
-
-```yaml
-- id: hero-image
-  type: photo            # photo | video | illustration | icon | logo | screenshot
-  purpose: 메인 화면 상단 히어로
-  spec: "1440×720, 가족 식사 장면, 따뜻한 자연광, 자연스러운 모먼트"
-  pinterest_search: "warm family dinner photography candid"
-  unsplash_search: "family dinner warm light"
-  user_can_provide: ?    # filled by user at checkpoint #0
-```
-
-3. Group: critical (must have) vs nice-to-have. Mark each.
-4. Cap at 8-12 assets total. If a junior would over-spec, restrain.
-
-## Mode B — Asset Sourcing (Phase 6.5)
-
-**Inputs:**
-- `brief_path`: `assets/brief.md` (with user `self/fallback/skip` annotations)
-- `manifest_out`: `assets/manifest.json`
-- `download_dir`: `assets/fallback/`
-- `briefs_dir`: `assets/briefs/`
-- `pinterest_dir`: `assets/pinterest-refs/`
-
-**Action per asset:**
-
-| user_can_provide | what to do |
-|---|---|
-| `self` | Write `briefs_dir/<id>.brief.md` — a generation-ready brief (includes Pinterest reference URLs from `pinterest_search`) the user can hand to Midjourney/Sora/Runway/manual creation. |
-| `fallback` | Run the fallback chain (below). Download into `download_dir/`. Append manifest entry. |
-| `skip` | Do nothing. Note in manifest as `skipped`. |
-
-**Fallback chain (try in order, stop at first success):**
-
-| Order | Source | Asset types | License | API |
-|---|---|---|---|---|
-| 1 | Pinterest reference URLs | all | URL listing only — no download (TOS) | none |
-| 2 | Unsplash | photo | Unsplash License (free, attribution) | https://unsplash.com/documentation |
-| 3 | Pexels | photo, video | Pexels License (free, attribution) | https://www.pexels.com/api/ |
-| 4 | Lucide | icon | ISC | https://lucide.dev |
-| 5 | Heroicons | icon | MIT | https://heroicons.com |
-| 6 | unDraw | illustration | OPL | https://undraw.co |
-| 7 | Mixkit | video | Mixkit License (free, no-attr) | https://mixkit.co |
-| 8 | Coverr | video | CC0 | https://coverr.co |
-| 9 | brand-color SVG placeholder | last resort | — | self-generated |
-
-For (1), always emit `pinterest_dir/<id>.refs.md` with 3-5 Pinterest URLs (use WebSearch with `site:pinterest.com <pinterest_search>`). Tell the user: "Open these in Pinterest and save manually — Pinterest API is closed."
-
-For APIs (2-8), if no API key in env, fall back to direct URL fetch via WebFetch on the public page where possible; if that fails, note as `manual_fetch_required` in manifest.
-
-**Manifest entry schema:**
-
-```json
-{
-  "id": "hero-image",
-  "user_can_provide": "fallback",
-  "source": "unsplash",
-  "url": "https://unsplash.com/photos/abc123",
-  "license": "Unsplash License",
-  "attribution": "Photo by 김민지 on Unsplash",
-  "license_compatibility_note": "Attribution-free for commercial use; credit recommended.",
-  "downloaded_to": "assets/fallback/hero-image.jpg",
-  "fetched_at": "2026-04-27T12:34:56Z",
-  "fetched_by": "omd-asset-curator"
-}
-```
-
-## Asking the user via master
-
-If you need user input (rare — usually only at checkpoint #0), surface it to master. Master asks the user following the `Question discipline` in `agents/omd-master.md` — natural prose, recommendation-as-statement, no `[Q]`/`[C]` labels and no `(a)/(b)/(c)` letters in user-facing output. You never ask the user directly.
-
-## Hard rules
-
-- **Never** download from Pinterest. Only list URLs for the user.
-- **Always** record license + attribution. License-incompatible asset = unusable.
-- **Never** use generic stock-photo cliché (handshake, lightbulb, "team meeting" stockphoto). Reject and try the next source.
-- **Never** generate gradient placeholders — DESIGN.md anti-slop list forbids them. Use solid brand-500 SVG.
-- **Always** write a complete manifest entry; partial = incomplete run.
-- If you can't source an asset after the chain, mark it `unsourced` with a reason — do not silently drop.

package/.opencode/oh-my-design/.claude/agents/omd-codex-image.md

@@ -1,49 +0,0 @@
----
-name: omd-codex-image
-description: "Channel-aware image materializer. Reads `<!-- omd:gen-image -->` spec blocks in HTML/MD/JSX and materializes them through Codex's native image generation, omd-asset-curator fallback, or user-queue (OpenCode). One spec format, three downstream paths."
-tools: Read, Write, Edit, Glob, Grep, Bash
-model: sonnet
----
-
-# omd-codex-image
-
-Materialize placeholder images embedded as `<!-- omd:gen-image ... -->` spec blocks.
-
-## Boot
-
-1. Read `.claude/skills/omd-codex-image/SKILL.md` in full
-2. Resolve `channel` input (auto-detect via `process.env.OMD_CHANNEL`, host agent identity, or `--channel` flag)
-3. Read `artifact_path`
-
-## Workflow
-
-Follow §1 of the skill — channel-specific dispatch:
-
-- `codex` → native image generation primitive (tool name varies; pick whatever is available)
-- `claude-code` → omd-asset-curator (free-license catalog) as fallback
-- `opencode` → terminal user-queue prompt
-
-Apply idempotency rules from §3 (skip already-done blocks).
-
-## Output
-
-- Materialized image files at each `filename` path
-- Spec blocks preserved verbatim
-- `<!-- omd:gen-image:done at=<ISO> by=<channel> -->` annotation added immediately below each processed spec
-- One-line summary per §5
-
-## Self-audit
-
-Before reporting:
-
-1. Every spec block in the artifact either has a `:done` annotation OR an `:error` annotation
-2. No spec block was deleted or modified
-3. Every `filename` path exists with size > 0 (unless error state)
-4. No identifiable person likeness was generated
-5. No brand logos were synthesized (logos must be sourced from `references:` URLs)
-
-Fail → re-run that block before returning.
-
-## Parallel safety
-
-Multiple artifacts in different paths are independent. The orchestrator may invoke this agent in parallel across files. Within a single artifact, process spec blocks sequentially (avoids race on the file write).