@ultrakit/ultrakit 0.0.0

package/dist/template/.opencode/skill/full-output-enforcement/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: full-output-enforcement
+description: MUST load when generating complete files, long code blocks, or any output where truncation or placeholder comments like '// ... rest of code' would be harmful. Bans all placeholder patterns and enforces exhaustive, unabridged output.
+---
+
+## When to Use
+
+- When generating complete files, long code blocks, or full configuration outputs
+- When truncation or placeholder comments like `// ... rest of code` would be harmful
+- When the user needs exhaustive, unabridged output
+
+## When NOT to Use
+
+- For short code snippets or single-function responses
+- When summarization is explicitly requested
+- For conversational responses that don't involve code generation
+
+
+# Full-Output Enforcement
+
+## Baseline
+
+Treat every task as production-critical. A partial output is a broken output. Do not optimize for brevity — optimize for completeness. If the user asks for a full file, deliver the full file. If the user asks for 5 components, deliver 5 components. No exceptions.
+
+## Banned Output Patterns
+
+The following patterns are hard failures. Never produce them:
+
+**In code blocks:** `// ...`, `// rest of code`, `// implement here`, `// TODO`, `/* ... */`, `// similar to above`, `// continue pattern`, `// add more as needed`, bare `...` standing in for omitted code
+
+**In prose:** "Let me know if you want me to continue", "I can provide more details if needed", "for brevity", "the rest follows the same pattern", "similarly for the remaining", "and so on" (when replacing actual content), "I'll leave that as an exercise"
+
+**Structural shortcuts:** Outputting a skeleton when the request was for a full implementation. Showing the first and last section while skipping the middle. Replacing repeated logic with one example and a description. Describing what code should do instead of writing it.
+
+## Execution Process
+
+1. **Scope** — Read the full request. Count how many distinct deliverables are expected (files, functions, sections, answers). Lock that number.
+2. **Build** — Generate every deliverable completely. No partial drafts, no "you can extend this later."
+3. **Cross-check** — Before output, re-read the original request. Compare your deliverable count against the scope count. If anything is missing, add it before responding.
+
+## Handling Long Outputs
+
+When a response approaches the token limit:
+
+- Do not compress remaining sections to squeeze them in.
+- Do not skip ahead to a conclusion.
+- Write at full quality up to a clean breakpoint (end of a function, end of a file, end of a section).
+- End with:
+
+```
+[PAUSED — X of Y complete. Send "continue" to resume from: next section name]
+```
+
+On "continue", pick up exactly where you stopped. No recap, no repetition.
+
+## Quick Check
+
+Before finalizing any response, verify:
+- No banned patterns from the list above appear anywhere in the output
+- Every item the user requested is present and finished
+- Code blocks contain actual runnable code, not descriptions of what code would do
+- Nothing was shortened to save space

package/dist/template/.opencode/skill/gemini-large-context/SKILL.md

@@ -0,0 +1,216 @@
+---
+name: gemini-large-context
+description: Use when analyzing large codebases, comparing multiple files, or researching project-wide patterns that exceed typical context limits - leverages Gemini CLI's 1M token context window for comprehensive analysis
+version: 1.0.0
+tags: [research, context]
+dependencies: []
+---
+
+# Gemini CLI Large Context Analysis
+
+## When to Use
+
+- Large, multi-file or project-wide analysis that exceeds local context limits.
+
+## When NOT to Use
+
+- Small, focused tasks that fit within normal context or require edits.
+
+## Overview
+
+Use Gemini CLI's massive context window (1M tokens) when analysis requires more context than available in current session. Ideal for codebase-wide searches, multi-file comparisons, and pattern discovery across large projects.
+
+## When to Use
+
+- Analyzing entire codebases or large directories (100KB+)
+- Comparing multiple large files simultaneously
+- Understanding project-wide patterns or architecture
+- Context window insufficient for current task
+- Verifying feature implementations across codebase
+- Research that needs to scan many files at once
+
+## Quick Reference
+
+```bash
+# Basic non-interactive analysis
+gemini -p "@src/ Summarize architecture"
+
+# Multiple directories
+gemini -p "@src/ @tests/ Analyze test coverage"
+
+# All project files
+gemini --all-files -p "Project overview"
+
+# Specific model (Pro = 1M context)
+gemini -m gemini-2.5-pro -p "@src/ Deep analysis"
+```
+
+## File/Directory Inclusion Syntax
+
+```bash
+# Single file
+gemini -p "@src/main.py Explain this file"
+
+# Multiple files
+gemini -p "@package.json @src/index.js Analyze dependencies"
+
+# Entire directory (recursive)
+gemini -p "@src/ Summarize architecture"
+
+# Multiple directories
+gemini -p "@src/ @tests/ Analyze test coverage"
+
+# Current directory
+gemini -p "@./ Project overview"
+
+# Alternative: all files flag
+gemini --all-files -p "Analyze project structure"
+```
+
+## Research Patterns
+
+### Architecture Analysis
+
+```bash
+gemini -p "@src/
+Describe:
+1. Overall architecture pattern (MVC, Clean, etc.)
+2. Key modules and their responsibilities
+3. Data flow between components
+4. External dependencies and integrations"
+```
+
+### Feature Implementation Check
+
+```bash
+gemini -p "@src/ @lib/
+Has [FEATURE] been implemented?
+Show:
+- Relevant files and functions
+- Implementation approach
+- Any gaps or incomplete areas"
+```
+
+### Pattern Discovery
+
+```bash
+gemini -p "@src/
+Find all instances of [PATTERN]:
+- File paths
+- Implementation variations
+- Consistency assessment"
+```
+
+### Security Audit
+
+```bash
+gemini -p "@src/ @api/
+Security review:
+- Input validation practices
+- Authentication/authorization patterns
+- SQL injection protections
+- XSS prevention measures"
+```
+
+### Test Coverage Analysis
+
+```bash
+gemini -p "@src/ @tests/
+Assess test coverage:
+- Which modules have tests?
+- Which are missing tests?
+- Test quality (unit vs integration)
+- Edge cases covered"
+```
+
+## Integration with OpenCode Workflow
+
+### For Task-Constrained Research
+
+When researching within task boundaries:
+
+```bash
+# 1. Include bead spec in context
+gemini -p "@src/ @.beads/artifacts/br-xxx/spec.md
+Research implementations matching spec constraints"
+
+# 2. Save findings to bead artifacts
+# Write to .beads/artifacts/br-xxx/research.md
+```
+
+### Delegating Large Research to Gemini
+
+In AGENTS.md or prompts, instruct agents:
+
+```markdown
+When analysis requires more than 100KB of files:
+
+1. Use Gemini CLI: `gemini -p "@[paths] [question]"`
+2. Capture output
+3. Synthesize findings in response
+```
+
+## Output Options
+
+```bash
+# Plain text (default)
+gemini -p "query"
+
+# JSON for parsing
+gemini -p "query" --output-format json
+
+# Streaming for long ops
+gemini -p "query" --output-format stream-json
+```
+
+## Common Research Queries
+
+- **Architecture overview:** `gemini -p "@src/ Describe architecture"`
+- **Find implementations:** `gemini -p "@src/ Where is [X] implemented?"`
+- **Pattern audit:** `gemini -p "@src/ Find all [pattern] usages"`
+- **Dependency analysis:** `gemini -p "@package.json @src/ Analyze dependency usage"`
+- **Code quality:** `gemini -p "@src/ Identify code smells"`
+- **Migration planning:** `gemini -p "@src/ Plan migration from [A] to [B]"`
+
+## Configuration
+
+### Authentication
+
+```bash
+# Google login (free tier: 60 req/min, 1000/day)
+gemini  # Follow OAuth flow
+
+# Or API key
+export GEMINI_API_KEY="your-key"
+```
+
+### Model Selection
+
+For most analysis tasks, **`gemini-2.5-pro`** is the best choice—it has a 1M token context window and handles code, text, and image analysis exceptionally well. This is the default model.
+
+Use **`gemini-2.5-flash`** when you need faster responses and don't need the full context window.
+
+**Important:** If you're analyzing images or screenshots, use `gemini-2.5-pro`. Image generation models like `imagen-3.0-generate-002` are for _creating_ new images, not understanding existing ones.
+
+```bash
+# Gemini 2.5 Pro (1M context) - default, best for analysis
+gemini -p "query"
+
+# Gemini Flash (faster, smaller context)
+gemini -m gemini-2.5-flash -p "query"
+```
+
+## Best Practices
+
+1. **Scope appropriately** - Include only relevant directories
+2. **Be specific** - Ask focused questions, not vague queries
+3. **Use for read-only analysis** - Don't ask Gemini to modify files in non-interactive mode
+4. **Capture output** - Redirect to file for long analyses: `gemini -p "..." > analysis.md`
+5. **Combine with local tools** - Use Gemini for research, local tools for implementation
+
+## Limitations
+
+- Non-interactive mode: no tool approvals (file writes, shell commands)
+- `@file` syntax: best in interactive mode
+- Network dependency: requires internet connection
+- Rate limits: 60 req/min free tier

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.