oh-my-opencode 4.9.2 → 4.11.0

package/dist/skills/frontend/references/ui-ux-db/scripts/search.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+UI/UX Pro Max Search - BM25 search engine for UI/UX style guides
+Usage: python search.py "<query>" [--domain <domain>] [--stack <stack>] [--max-results 3]
+       python search.py "<query>" --design-system [-p "Project Name"]
+       python search.py "<query>" --design-system --persist [-p "Project Name"] [--page "dashboard"]
+
+Domains: style, prompt, color, chart, landing, product, ux, typography
+Stacks: html-tailwind, react, nextjs
+
+Persistence (Master + Overrides pattern):
+  --persist    Save design system to design-system/MASTER.md
+  --page       Also create a page-specific override file in design-system/pages/
+"""
+
+import argparse
+import sys
+import io
+from core import CSV_CONFIG, AVAILABLE_STACKS, MAX_RESULTS, search, search_stack
+from design_system import generate_design_system, persist_design_system
+
+# Force UTF-8 for stdout/stderr to handle emojis on Windows (cp1252 default)
+if sys.stdout.encoding and sys.stdout.encoding.lower() != 'utf-8':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+if sys.stderr.encoding and sys.stderr.encoding.lower() != 'utf-8':
+    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
+
+
+def format_output(result):
+    """Format results for Claude consumption (token-optimized)"""
+    if "error" in result:
+        return f"Error: {result['error']}"
+
+    output = []
+    if result.get("stack"):
+        output.append(f"## UI Pro Max Stack Guidelines")
+        output.append(f"**Stack:** {result['stack']} | **Query:** {result['query']}")
+    else:
+        output.append(f"## UI Pro Max Search Results")
+        output.append(f"**Domain:** {result['domain']} | **Query:** {result['query']}")
+    output.append(f"**Source:** {result['file']} | **Found:** {result['count']} results\n")
+
+    for i, row in enumerate(result['results'], 1):
+        output.append(f"### Result {i}")
+        for key, value in row.items():
+            value_str = str(value)
+            if len(value_str) > 300:
+                value_str = value_str[:300] + "..."
+            output.append(f"- **{key}:** {value_str}")
+        output.append("")
+
+    return "\n".join(output)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="UI Pro Max Search")
+    parser.add_argument("query", help="Search query")
+    parser.add_argument("--domain", "-d", choices=list(CSV_CONFIG.keys()), help="Search domain")
+    parser.add_argument("--stack", "-s", choices=AVAILABLE_STACKS, help="Stack-specific search (html-tailwind, react, nextjs)")
+    parser.add_argument("--max-results", "-n", type=int, default=MAX_RESULTS, help="Max results (default: 3)")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    # Design system generation
+    parser.add_argument("--design-system", "-ds", action="store_true", help="Generate complete design system recommendation")
+    parser.add_argument("--project-name", "-p", type=str, default=None, help="Project name for design system output")
+    parser.add_argument("--format", "-f", choices=["ascii", "markdown"], default="ascii", help="Output format for design system")
+    # Persistence (Master + Overrides pattern)
+    parser.add_argument("--persist", action="store_true", help="Save design system to design-system/MASTER.md (creates hierarchical structure)")
+    parser.add_argument("--page", type=str, default=None, help="Create page-specific override file in design-system/pages/")
+    parser.add_argument("--output-dir", "-o", type=str, default=None, help="Output directory for persisted files (default: current directory)")
+
+    args = parser.parse_args()
+
+    # Design system takes priority
+    if args.design_system:
+        result = generate_design_system(
+            args.query, 
+            args.project_name, 
+            args.format,
+            persist=args.persist,
+            page=args.page,
+            output_dir=args.output_dir
+        )
+        print(result)
+        
+        # Print persistence confirmation
+        if args.persist:
+            project_slug = args.project_name.lower().replace(' ', '-') if args.project_name else "default"
+            print("\n" + "=" * 60)
+            print(f"✅ Design system persisted to design-system/{project_slug}/")
+            print(f"   📄 design-system/{project_slug}/MASTER.md (Global Source of Truth)")
+            if args.page:
+                page_filename = args.page.lower().replace(' ', '-')
+                print(f"   📄 design-system/{project_slug}/pages/{page_filename}.md (Page Overrides)")
+            print("")
+            print(f"📖 Usage: When building a page, check design-system/{project_slug}/pages/[page].md first.")
+            print(f"   If exists, its rules override MASTER.md. Otherwise, use MASTER.md.")
+            print("=" * 60)
+    # Stack search
+    elif args.stack:
+        result = search_stack(args.query, args.stack, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))
+    # Domain search
+    else:
+        result = search(args.query, args.domain, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))

package/dist/skills/frontend/scripts/perfection/lighthouse-audit.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "playwright",
+#     "typer",
+#     "rich",
+# ]
+# ///
+
+# ─── How to run ───
+# 1. Install uv (if not installed):
+#      curl -LsSf https://astral.sh/uv/install.sh | sh
+# 2. Install Playwright browsers (one-time):
+#      uv run --with playwright python -m playwright install chromium
+# 3. Run:
+#      uv run lighthouse-audit.py https://example.com
+#      uv run lighthouse-audit.py https://example.com --desktop-only
+#      uv run lighthouse-audit.py https://example.com --threshold 95
+# ──────────────────
+
+"""Lighthouse audit via real Playwright Chrome.
+
+Follows the frontend skill perfection ruleset:
+  - NEVER use `lighthouse` CLI (uses headless-shell, not real Chrome)
+  - Use Playwright with channel="chrome" (real Chrome stable)
+  - Run lighthouse Node API via the Playwright CDP endpoint
+  - Mobile preset (primary) + Desktop preset (secondary)
+  - 100 in every category is the floor
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import typer
+from rich import print as rprint
+from rich.table import Table
+
+
+# Lighthouse config as Node.js script — run via subprocess
+LIGHTHOUSE_RUNNER_JS = """\
+const lighthouse = require('lighthouse');
+const chromeLauncher = require('chrome-launcher');
+
+const url = process.argv[2];
+const port = parseInt(process.argv[3]);
+const preset = process.argv[4]; // 'mobile' or 'desktop'
+
+const config = {
+  extends: 'lighthouse:default',
+  settings: {
+    formFactor: preset === 'desktop' ? 'desktop' : 'mobile',
+    throttling: preset === 'desktop'
+      ? { rttMs: 40, throughputKbps: 10240, cpuSlowdownMultiplier: 1 }
+      : undefined,
+    screenEmulation: preset === 'desktop'
+      ? { mobile: false, width: 1350, height: 940, deviceScaleFactor: 1 }
+      : undefined,
+    onlyCategories: ['performance', 'accessibility', 'best-practices', 'seo'],
+  },
+};
+
+(async () => {
+  const result = await lighthouse(url, { port, logLevel: 'error' }, config);
+  const categories = result.lhr.categories;
+  const output = {};
+  for (const [key, cat] of Object.entries(categories)) {
+    output[key] = Math.round(cat.score * 100);
+  }
+  console.log(JSON.stringify(output));
+})();
+"""
+
+
+def _check_node_deps() -> bool:
+    """Check if lighthouse and chrome-launcher are available."""
+    result = subprocess.run(
+        ["node", "-e", "require('lighthouse'); require('chrome-launcher')"],
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0
+
+
+def _install_node_deps() -> None:
+    """Install lighthouse + chrome-launcher globally."""
+    rprint("[yellow]Installing lighthouse + chrome-launcher...[/yellow]")
+    subprocess.run(
+        ["npm", "install", "-g", "lighthouse", "chrome-launcher"],
+        capture_output=True,
+        check=True,
+    )
+
+
+def _run_lighthouse_via_cdp(url: str, cdp_port: int, preset: str) -> dict[str, int]:
+    """Run lighthouse against a CDP endpoint."""
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".js", delete=False) as f:
+        f.write(LIGHTHOUSE_RUNNER_JS)
+        js_path = f.name
+
+    try:
+        result = subprocess.run(
+            ["node", js_path, url, str(cdp_port), preset],
+            capture_output=True,
+            text=True,
+            timeout=120,
+        )
+        if result.returncode != 0:
+            rprint(f"[red]Lighthouse failed:[/red] {result.stderr}")
+            raise SystemExit(1)
+
+        return json.loads(result.stdout.strip())
+    finally:
+        Path(js_path).unlink(missing_ok=True)
+
+
+def _run_with_playwright(url: str, preset: str) -> dict[str, int]:
+    """Launch real Chrome via Playwright, run Lighthouse against CDP."""
+    from playwright.sync_api import sync_playwright
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(
+            channel="chrome",
+            headless=True,
+            args=["--remote-debugging-port=0"],
+        )
+
+        # Get the actual CDP port from browser
+        cdp_url = browser.contexts[0].pages[0].url if browser.contexts else ""
+        # Use the browser's websocket endpoint to extract port
+        ws_endpoint = browser._impl_obj._connection._transport._ws_url  # noqa: SLF001
+        # Extract port from ws://127.0.0.1:PORT/...
+        port_str = ws_endpoint.split("://")[1].split(":")[1].split("/")[0]
+        cdp_port = int(port_str)
+
+        try:
+            scores = _run_lighthouse_via_cdp(url, cdp_port, preset)
+        finally:
+            browser.close()
+
+    return scores
+
+
+def _print_scores(scores: dict[str, int], preset: str, threshold: int) -> bool:
+    """Print scores as a rich table. Returns True if all pass."""
+    table = Table(title=f"Lighthouse — {preset}")
+    table.add_column("Category")
+    table.add_column("Score", justify="right")
+    table.add_column("Status")
+
+    all_pass = True
+    for category, score in scores.items():
+        status = "[green]✓ PASS[/green]" if score >= threshold else "[red]✗ FAIL[/red]"
+        if score < threshold:
+            all_pass = False
+        color = "green" if score >= threshold else "red"
+        table.add_row(category, f"[{color}]{score}[/{color}]", status)
+
+    rprint(table)
+    return all_pass
+
+
+def main(
+    url: str = typer.Argument(help="URL to audit"),
+    threshold: int = typer.Option(100, "--threshold", "-t", help="Minimum passing score"),
+    desktop_only: bool = typer.Option(False, "--desktop-only", help="Skip mobile audit"),
+    mobile_only: bool = typer.Option(False, "--mobile-only", help="Skip desktop audit"),
+) -> None:
+    """Run Lighthouse audit via real Playwright Chrome."""
+    # Check node deps
+    if not _check_node_deps():
+        _install_node_deps()
+
+    all_pass = True
+
+    if not desktop_only:
+        rprint(f"\n[bold]Auditing (mobile):[/bold] {url}")
+        mobile_scores = _run_with_playwright(url, "mobile")
+        if not _print_scores(mobile_scores, "Mobile", threshold):
+            all_pass = False
+
+    if not mobile_only:
+        rprint(f"\n[bold]Auditing (desktop):[/bold] {url}")
+        desktop_scores = _run_with_playwright(url, "desktop")
+        if not _print_scores(desktop_scores, "Desktop", threshold):
+            all_pass = False
+
+    if all_pass:
+        rprint("\n[green bold]✓ All categories passed![/green bold]")
+    else:
+        rprint(f"\n[red bold]✗ Some categories below {threshold}. Not done yet.[/red bold]")
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    typer.run(main)

package/dist/skills/git-master/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: git-master
+description: "MUST USE whenever a task needs a commit or git-history investigation. Covers atomic commits, staging, commit-message style, rebase, squash, fixup/autosquash, blame, bisect, reflog, git log -S/-G, and questions like who wrote this or when was this added. Do not use for ordinary code edits unless the user asks for git work."
+---
+
+# Git Master
+
+Use this skill when the user asks you to operate on Git history or answer a Git-history question. Be exact, conservative, and evidence-led. Read the repository state before you infer anything.
+
+## Mode Gate
+
+Classify the request first:
+
+- `COMMIT`: stage and commit local changes.
+- `REBASE`: rebase, squash, fixup, autosquash, reorder, split, or otherwise rewrite branch history.
+- `HISTORY`: answer when, where, who, why, or which commit changed something.
+- `STATUS`: inspect branch, diff, or working-tree state without changing it.
+
+Do not commit, rebase, push, force-push, reset, stash-pop, or delete anything unless the user explicitly asked for that operation. If the request is only investigative, report findings and stop.
+
+## Ground Truth
+
+Gather independent facts in parallel when the tools allow it:
+
+```bash
+git status --short
+git diff --stat
+git diff --staged --stat
+git branch --show-current
+git log -30 --oneline
+git log -30 --pretty=format:%s
+git rev-parse --abbrev-ref @{upstream}
+git merge-base HEAD origin/main
+git merge-base HEAD origin/master
+```
+
+Missing upstream or missing `main`/`master` is normal. Fall back to the best available branch or report the missing fact. Never treat a failed lookup as proof.
+
+## Commit Mode
+
+Commit only the user's requested changes. Preserve unrelated dirty work.
+
+1. Detect message style from recent history. Use the dominant local pattern, language, and casing. Do not default to Conventional Commits unless the repo uses them.
+2. Inspect the full diff, not only filenames. Separate unrelated user edits from the requested commit.
+3. Build atomic groups by behavior, module, and revertability. Keep implementation and its direct tests together.
+4. Prefer multiple commits for unrelated concerns. A single commit is acceptable only when the changed files form one indivisible behavior or the user explicitly asks for one commit.
+5. Stage by path or hunk so each commit contains only its atomic group.
+6. Before each commit, verify `git diff --staged --stat` and enough staged diff to prove the group is right.
+7. Commit with the detected style. After each commit, verify `git log -1 --oneline`.
+
+Grouping rules:
+
+- Split different features, modules, generated artifacts, config, docs, and test-only changes unless they are inseparable.
+- Keep generated files with the source change that produced them when omitting them would leave the repo inconsistent.
+- Never hide failing or unrelated changes inside a broad commit.
+
+Final report: list commit hashes, messages, and any remaining uncommitted files.
+
+## Rebase Mode
+
+History rewriting is a shared-impact operation.
+
+- Never rebase or rewrite `main`, `master`, `dev`, release branches, or a protected branch unless the user explicitly named that exact operation.
+- If commits may already be pushed, ask before force-pushing. Use `--force-with-lease`, never plain `--force`.
+- If the worktree is dirty, preserve it intentionally before rebasing. Do not stash-pop over conflicts without checking what changed.
+- For fixups, prefer `git commit --fixup=<hash>` followed by `GIT_SEQUENCE_EDITOR=: git rebase -i --autosquash <base>`.
+- For conflicts, read the conflicting files and resolve by intent. Do not choose ours/theirs blindly.
+- If a rebase goes wrong, use `git rebase --abort` first. Use reflog only after explaining the recovery path.
+
+After rewriting, run the relevant tests or at least the project's cheapest smoke check, then show the new branch log from base to HEAD.
+
+## History Mode
+
+Choose the Git tool by the question:
+
+- `git log -S "text"`: when the count of an exact string changed.
+- `git log -G "regex"`: when diffs touched lines matching a pattern.
+- `git blame -L start,end -- file`: who last changed specific lines.
+- `git log --follow -- file`: history across renames for one file.
+- `git show <hash>`: inspect the commit that appears relevant.
+- `git bisect`: find the first bad commit when there is a deterministic pass/fail command and known good/bad bounds.
+- `git reflog`: recover or explain recent local history movement.
+
+Always cite the exact command evidence in the answer: commit hash, subject, file path, and line or diff context when relevant. If the evidence is ambiguous, say what remains unproven.
+
+## Safety Checks
+
+Before any write to Git history:
+
+- Current branch is known.
+- Dirty work is accounted for.
+- Upstream/pushed status is known or explicitly unknown.
+- The operation matches the user's request.
+- Recovery path is known (`rebase --abort`, reflog hash, or untouched worktree).
+
+Before finishing:
+
+- Run the most relevant verification available for the changed behavior or history operation.
+- Report commands that passed and any command you could not run.
+- Leave the worktree state explicit.

package/dist/skills/git-master/agents/openai.yaml

@@ -0,0 +1,13 @@
+interface:
+  display_name: "git-master (omo)"
+  short_description: "Atomic Git commits, history surgery, and source archaeology"
+  search_terms:
+    - "git-master"
+    - "git commit"
+    - "atomic commit"
+    - "rebase"
+    - "squash"
+    - "git blame"
+    - "git bisect"
+    - "history search"
+  default_prompt: "Use $git-master to inspect the repository state, preserve unrelated work, and handle the requested Git operation with atomic grouping, history safety checks, and evidence-backed verification."