opencodekit 0.20.8 → 0.21.0

package/dist/template/.opencode/plugin/sdk/copilot/responses/tool/web-search.ts

@@ -0,0 +1,102 @@
+import { createProviderToolFactory } from "@ai-sdk/provider-utils"
+import { z } from "zod/v4"
+
+export const webSearchArgsSchema = z.object({
+  filters: z
+    .object({
+      allowedDomains: z.array(z.string()).optional(),
+    })
+    .optional(),
+
+  searchContextSize: z.enum(["low", "medium", "high"]).optional(),
+
+  userLocation: z
+    .object({
+      type: z.literal("approximate"),
+      country: z.string().optional(),
+      city: z.string().optional(),
+      region: z.string().optional(),
+      timezone: z.string().optional(),
+    })
+    .optional(),
+})
+
+export const webSearchToolFactory = createProviderToolFactory<
+  {
+    // Web search doesn't take input parameters - it's controlled by the prompt
+  },
+  {
+    /**
+     * Filters for the search.
+     */
+    filters?: {
+      /**
+       * Allowed domains for the search.
+       * If not provided, all domains are allowed.
+       * Subdomains of the provided domains are allowed as well.
+       */
+      allowedDomains?: string[]
+    }
+
+    /**
+     * Search context size to use for the web search.
+     * - high: Most comprehensive context, highest cost, slower response
+     * - medium: Balanced context, cost, and latency (default)
+     * - low: Least context, lowest cost, fastest response
+     */
+    searchContextSize?: "low" | "medium" | "high"
+
+    /**
+     * User location information to provide geographically relevant search results.
+     */
+    userLocation?: {
+      /**
+       * Type of location (always 'approximate')
+       */
+      type: "approximate"
+      /**
+       * Two-letter ISO country code (e.g., 'US', 'GB')
+       */
+      country?: string
+      /**
+       * City name (free text, e.g., 'Minneapolis')
+       */
+      city?: string
+      /**
+       * Region name (free text, e.g., 'Minnesota')
+       */
+      region?: string
+      /**
+       * IANA timezone (e.g., 'America/Chicago')
+       */
+      timezone?: string
+    }
+  }
+>({
+  id: "openai.web_search",
+  inputSchema: z.object({
+    action: z
+      .discriminatedUnion("type", [
+        z.object({
+          type: z.literal("search"),
+          query: z.string().nullish(),
+        }),
+        z.object({
+          type: z.literal("open_page"),
+          url: z.string(),
+        }),
+        z.object({
+          type: z.literal("find"),
+          url: z.string(),
+          pattern: z.string(),
+        }),
+      ])
+      .nullish(),
+  }),
+})
+
+export const webSearch = (
+  args: Parameters<typeof webSearchToolFactory>[0] = {}, // default
+) => {
+  return webSearchToolFactory(args)
+}

package/dist/template/.opencode/skill/gh-address-comments/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: gh-address-comments
+description: Use when the user asks to review and address GitHub PR comments/threads for the current branch using gh CLI.
+version: 1.0.0
+tags: [workflow, git, agent-coordination]
+dependencies: []
+---
+
+# gh-address-comments
+
+Fetch PR comments and review threads, then apply selected fixes.
+
+## When to Use
+
+- User asks to resolve PR review comments
+- User wants a numbered list of comment threads to triage
+
+## When NOT to Use
+
+- No open PR associated with current branch
+- `gh` is unavailable/auth is missing and user declines auth
+
+## Workflow
+
+1. Check auth: `gh auth status`
+2. Fetch comments: `python3 .opencode/skill/gh-address-comments/scripts/fetch_comments.py`
+3. Present numbered comment threads with short fix summaries
+4. Ask which comments to address
+5. Implement only selected fixes and report results

package/dist/template/.opencode/skill/gh-address-comments/scripts/fetch_comments.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""
+Fetch all PR conversation comments + reviews + review threads (inline threads)
+for the PR associated with the current git branch, by shelling out to:
+
+  gh api graphql
+
+Requires:
+  - `gh auth login` already set up
+  - current branch has an associated (open) PR
+
+Usage:
+  python fetch_comments.py > pr_comments.json
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+from typing import Any
+
+QUERY = """\
+query(
+  $owner: String!,
+  $repo: String!,
+  $number: Int!,
+  $commentsCursor: String,
+  $reviewsCursor: String,
+  $threadsCursor: String
+) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      number
+      url
+      title
+      state
+
+      # Top-level "Conversation" comments (issue comments on the PR)
+      comments(first: 100, after: $commentsCursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id
+          body
+          createdAt
+          updatedAt
+          author { login }
+        }
+      }
+
+      # Review submissions (Approve / Request changes / Comment), with body if present
+      reviews(first: 100, after: $reviewsCursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id
+          state
+          body
+          submittedAt
+          author { login }
+        }
+      }
+
+      # Inline review threads (grouped), includes resolved state
+      reviewThreads(first: 100, after: $threadsCursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          id
+          isResolved
+          isOutdated
+          path
+          line
+          diffSide
+          startLine
+          startDiffSide
+          originalLine
+          originalStartLine
+          resolvedBy { login }
+          comments(first: 100) {
+            nodes {
+              id
+              body
+              createdAt
+              updatedAt
+              author { login }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+"""
+
+
+def _run(cmd: list[str], stdin: str | None = None) -> str:
+    p = subprocess.run(cmd, input=stdin, capture_output=True, text=True)
+    if p.returncode != 0:
+        raise RuntimeError(f"Command failed: {' '.join(cmd)}\n{p.stderr}")
+    return p.stdout
+
+
+def _run_json(cmd: list[str], stdin: str | None = None) -> dict[str, Any]:
+    out = _run(cmd, stdin=stdin)
+    try:
+        return json.loads(out)
+    except json.JSONDecodeError as e:
+        raise RuntimeError(f"Failed to parse JSON from command output: {e}\nRaw:\n{out}") from e
+
+
+def _ensure_gh_authenticated() -> None:
+    try:
+        _run(["gh", "auth", "status"])
+    except RuntimeError:
+        print("run `gh auth login` to authenticate the GitHub CLI", file=sys.stderr)
+        raise RuntimeError("gh auth status failed; run `gh auth login` to authenticate the GitHub CLI") from None
+
+
+def gh_pr_view_json(fields: str) -> dict[str, Any]:
+    # fields is a comma-separated list like: "number,headRepositoryOwner,headRepository"
+    return _run_json(["gh", "pr", "view", "--json", fields])
+
+
+def get_current_pr_ref() -> tuple[str, str, int]:
+    """
+    Resolve the PR for the current branch (whatever gh considers associated).
+    Works for cross-repo PRs too, by reading head repository owner/name.
+    """
+    pr = gh_pr_view_json("number,headRepositoryOwner,headRepository")
+    owner = pr["headRepositoryOwner"]["login"]
+    repo = pr["headRepository"]["name"]
+    number = int(pr["number"])
+    return owner, repo, number
+
+
+def gh_api_graphql(
+    owner: str,
+    repo: str,
+    number: int,
+    comments_cursor: str | None = None,
+    reviews_cursor: str | None = None,
+    threads_cursor: str | None = None,
+) -> dict[str, Any]:
+    """
+    Call `gh api graphql` using -F variables, avoiding JSON blobs with nulls.
+    Query is passed via stdin using query=@- to avoid shell newline/quoting issues.
+    """
+    cmd = [
+        "gh",
+        "api",
+        "graphql",
+        "-F",
+        "query=@-",
+        "-F",
+        f"owner={owner}",
+        "-F",
+        f"repo={repo}",
+        "-F",
+        f"number={number}",
+    ]
+    if comments_cursor:
+        cmd += ["-F", f"commentsCursor={comments_cursor}"]
+    if reviews_cursor:
+        cmd += ["-F", f"reviewsCursor={reviews_cursor}"]
+    if threads_cursor:
+        cmd += ["-F", f"threadsCursor={threads_cursor}"]
+
+    return _run_json(cmd, stdin=QUERY)
+
+
+def fetch_all(owner: str, repo: str, number: int) -> dict[str, Any]:
+    conversation_comments: list[dict[str, Any]] = []
+    reviews: list[dict[str, Any]] = []
+    review_threads: list[dict[str, Any]] = []
+
+    comments_cursor: str | None = None
+    reviews_cursor: str | None = None
+    threads_cursor: str | None = None
+
+    pr_meta: dict[str, Any] | None = None
+
+    while True:
+        payload = gh_api_graphql(
+            owner=owner,
+            repo=repo,
+            number=number,
+            comments_cursor=comments_cursor,
+            reviews_cursor=reviews_cursor,
+            threads_cursor=threads_cursor,
+        )
+
+        if "errors" in payload and payload["errors"]:
+            raise RuntimeError(f"GitHub GraphQL errors:\n{json.dumps(payload['errors'], indent=2)}")
+
+        pr = payload["data"]["repository"]["pullRequest"]
+        if pr_meta is None:
+            pr_meta = {
+                "number": pr["number"],
+                "url": pr["url"],
+                "title": pr["title"],
+                "state": pr["state"],
+                "owner": owner,
+                "repo": repo,
+            }
+
+        c = pr["comments"]
+        r = pr["reviews"]
+        t = pr["reviewThreads"]
+
+        conversation_comments.extend(c.get("nodes") or [])
+        reviews.extend(r.get("nodes") or [])
+        review_threads.extend(t.get("nodes") or [])
+
+        comments_cursor = c["pageInfo"]["endCursor"] if c["pageInfo"]["hasNextPage"] else None
+        reviews_cursor = r["pageInfo"]["endCursor"] if r["pageInfo"]["hasNextPage"] else None
+        threads_cursor = t["pageInfo"]["endCursor"] if t["pageInfo"]["hasNextPage"] else None
+
+        if not (comments_cursor or reviews_cursor or threads_cursor):
+            break
+
+    assert pr_meta is not None
+    return {
+        "pull_request": pr_meta,
+        "conversation_comments": conversation_comments,
+        "reviews": reviews,
+        "review_threads": review_threads,
+    }
+
+
+def main() -> None:
+    _ensure_gh_authenticated()
+    owner, repo, number = get_current_pr_ref()
+    result = fetch_all(owner, repo, number)
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/dist/template/.opencode/skill/gh-fix-ci/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: gh-fix-ci
+description: Use when a user asks to diagnose or fix failing GitHub PR checks in GitHub Actions using gh CLI and logs.
+version: 1.0.0
+tags: [debugging, devops, git]
+dependencies: []
+---
+
+# gh-fix-ci
+
+Diagnose failing PR checks, extract actionable logs, and propose focused fixes.
+
+## When to Use
+
+- User asks to fix failing GitHub PR checks
+- CI failures are in GitHub Actions
+
+## When NOT to Use
+
+- Checks are from external providers (Buildkite/Circle/etc.) without actionable logs in GitHub
+- No `gh` auth and user does not want to authenticate
+
+## Workflow
+
+1. Verify auth: `gh auth status`
+2. Resolve PR (`gh pr view --json number,url`) or use provided PR number/URL
+3. Run check inspector script
+4. Summarize failing checks and log snippets
+5. Propose fix plan and implement
+6. Re-run relevant checks
+
+## Script
+
+```bash
+python3 .opencode/skill/gh-fix-ci/scripts/inspect_pr_checks.py --repo . --pr 123
+```
+
+Add `--json` for machine-friendly output.