opencodekit 0.20.8 → 0.21.1

package/dist/template/.opencode/skill/prompt-leverage/scripts/augment_prompt.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""Automated prompt upgrader using the Prompt Leverage Framework."""
+
+from __future__ import annotations
+
+import argparse
+import re
+from textwrap import dedent
+
+
+TASK_KEYWORDS = {
+    "coding": [
+        "code",
+        "bug",
+        "repo",
+        "refactor",
+        "test",
+        "implement",
+        "fix",
+        "function",
+        "api",
+    ],
+    "research": [
+        "research",
+        "compare",
+        "find",
+        "latest",
+        "sources",
+        "analyze market",
+        "look up",
+    ],
+    "writing": ["write", "rewrite", "draft", "email", "memo", "blog", "copy", "tone"],
+    "review": ["review", "audit", "critique", "inspect", "evaluate", "assess"],
+    "planning": ["plan", "roadmap", "strategy", "framework", "outline"],
+    "analysis": ["analyze", "explain", "break down", "diagnose", "root cause"],
+}
+
+
+def detect_task(prompt: str) -> str:
+    """Detect task type by keyword matching."""
+    lowered = prompt.lower()
+    scores = {
+        task: sum(1 for keyword in keywords if keyword in lowered)
+        for task, keywords in TASK_KEYWORDS.items()
+    }
+    best_task, best_score = max(scores.items(), key=lambda item: item[1])
+    return best_task if best_score > 0 else "analysis"
+
+
+def infer_intensity(prompt: str, task: str) -> str:
+    """Infer intensity level from prompt content."""
+    lowered = prompt.lower()
+    if any(
+        token in lowered
+        for token in [
+            "careful",
+            "deep",
+            "thorough",
+            "high stakes",
+            "production",
+            "critical",
+        ]
+    ):
+        return "Deep"
+    if task in {"coding", "research", "review"}:
+        return "Standard"
+    return "Light"
+
+
+def build_tool_rules(task: str) -> str:
+    """Build task-specific tool rules."""
+    rules = {
+        "coding": "Inspect the relevant files and dependencies first. Validate the final change with the narrowest useful checks before broadening scope.",
+        "research": "Retrieve evidence from reliable sources before concluding. Do not guess facts that can be checked.",
+        "review": "Read enough surrounding context to understand intent before critiquing. Distinguish confirmed issues from plausible risks.",
+    }
+    return rules.get(
+        task,
+        "Use tools or extra context only when they materially improve correctness or completeness.",
+    )
+
+
+def build_output_contract(task: str) -> str:
+    """Build task-specific output contract."""
+    contracts = {
+        "coding": "Return the result in a practical execution format: concise summary, concrete changes or code, validation notes, and any remaining risks.",
+        "research": "Return a structured synthesis with key findings, supporting evidence, uncertainty where relevant, and a concise bottom line.",
+        "writing": "Return polished final copy in the requested tone and format. If useful, include a short rationale for major editorial choices.",
+        "review": "Return findings grouped by severity or importance, explain why each matters, and suggest the smallest credible next step.",
+    }
+    return contracts.get(
+        task,
+        "Return a clear, well-structured response matched to the task, with no unnecessary verbosity.",
+    )
+
+
+def upgrade_prompt(raw_prompt: str, task: str | None) -> str:
+    """Upgrade a raw prompt using the framework."""
+    normalized = re.sub(r"\s+", " ", raw_prompt).strip()
+    detected_task = task or detect_task(normalized)
+    intensity = infer_intensity(normalized, detected_task)
+    tool_rules = build_tool_rules(detected_task)
+    output_contract = build_output_contract(detected_task)
+
+    return dedent(
+        f"""
+        Objective:
+        - Complete this task: {normalized}
+        - Optimize for a correct, useful result rather than a merely plausible one.
+
+        Context:
+        - Preserve the user's original intent and constraints.
+        - Surface any key assumptions if required information is missing.
+
+        Work Style:
+        - Task type: {detected_task}
+        - Effort level: {intensity}
+        - Understand the problem broadly enough to avoid narrow mistakes, then go deep where the risk or complexity is highest.
+        - Use first-principles reasoning before proposing changes.
+        - For non-trivial work, review the result once with fresh eyes before finalizing.
+
+        Tool Rules:
+        - {tool_rules}
+
+        Output Contract:
+        - {output_contract}
+
+        Verification:
+        - Check correctness, completeness, and edge cases.
+        - Improve obvious weaknesses if a better approach is available within scope.
+
+        Done Criteria:
+        - Stop only when the response satisfies the task, matches the requested format, and passes the verification step.
+        """
+    ).strip()
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Upgrade a raw prompt into a framework-backed execution prompt."
+    )
+    parser.add_argument("prompt", help="Raw prompt text to upgrade.")
+    parser.add_argument(
+        "--task",
+        choices=sorted(TASK_KEYWORDS.keys()),
+        help="Optional explicit task type (auto-detected if not provided).",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    print(upgrade_prompt(args.prompt, args.task))
+
+
+if __name__ == "__main__":
+    main()

package/dist/template/.opencode/skill/screenshot/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: screenshot
+description: Use when the user explicitly asks for desktop/system screenshots or when browser/tool-specific capture is unavailable.
+version: 1.0.0
+tags: [debugging, ui, automation]
+dependencies: []
+---
+
+# screenshot
+
+Capture screenshots at OS level for desktop apps, windows, regions, or full screen.
+
+## When to Use
+
+- User asks for screenshot of desktop/app/window/region
+- You need non-browser captures (native app, OS UI, Electron shell)
+- Browser capture tools are unavailable or insufficient
+
+## When NOT to Use
+
+- Browser-only capture where Playwright/DevTools is enough
+- Design-file capture where Figma skills are available
+
+## Save Location Rules
+
+1. If user gives a path, save there.
+2. If user asks generally for a screenshot, use OS default screenshot location.
+3. If screenshot is for agent inspection, save to temp location.
+
+## Scripts
+
+- `scripts/take_screenshot.py` (macOS/Linux)
+- `scripts/take_screenshot.ps1` (Windows)
+- `scripts/ensure_macos_permissions.sh` (macOS preflight)
+
+## Quick Start
+
+```bash
+# macOS/Linux default capture
+python3 .opencode/skill/screenshot/scripts/take_screenshot.py
+
+# capture app window(s) on macOS to temp
+bash .opencode/skill/screenshot/scripts/ensure_macos_permissions.sh && \
+python3 .opencode/skill/screenshot/scripts/take_screenshot.py --app "Codex" --mode temp
+
+# region capture
+python3 .opencode/skill/screenshot/scripts/take_screenshot.py --mode temp --region 100,200,800,600
+```

package/dist/template/.opencode/skill/screenshot/scripts/ensure_macos_permissions.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ "$(uname)" != "Darwin" ]]; then
+  echo "ensure_macos_permissions.sh only supports macOS" >&2
+  exit 1
+fi
+
+if ! command -v swift >/dev/null 2>&1; then
+  echo "swift is required to check macOS screen capture permissions" >&2
+  exit 1
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PERM_SWIFT="$SCRIPT_DIR/macos_permissions.swift"
+MODULE_CACHE="${TMPDIR:-/tmp}/codex-swift-module-cache"
+mkdir -p "$MODULE_CACHE"
+
+screen_capture_status() {
+  local json
+  json="$(swift -module-cache-path "$MODULE_CACHE" "$PERM_SWIFT" "$@")"
+  python3 -c 'import json, sys; data=json.loads(sys.argv[1]); print("1" if data.get("screenCapture") else "0")' "$json"
+}
+
+if [[ -n "${CODEX_SANDBOX:-}" ]]; then
+  echo "Screen capture checks are blocked in the sandbox; rerun with escalated permissions." >&2
+  exit 3
+fi
+
+if [[ "$(screen_capture_status)" == "1" ]]; then
+  echo "Screen Recording permission already granted."
+  exit 0
+fi
+
+cat <<'MSG'
+This workflow needs macOS Screen Recording permission to capture screenshots.
+macOS will show a single system prompt for Screen Recording. Approve it, then
+return here. If macOS opens System Settings instead of prompting, enable Screen
+Recording for your terminal and rerun the command.
+MSG
+
+# Request permission once after explaining why it is needed.
+screen_capture_status --request >/dev/null || true
+
+if [[ "$(screen_capture_status)" != "1" ]]; then
+  cat <<'MSG'
+Screen Recording is still not granted.
+Open System Settings > Privacy & Security > Screen Recording and enable it for
+your terminal (and Codex if needed), then rerun your screenshot command.
+MSG
+  exit 2
+fi
+
+echo "Screen Recording permission granted."

package/dist/template/.opencode/skill/screenshot/scripts/macos_display_info.swift

@@ -0,0 +1,22 @@
+import AppKit
+import Foundation
+
+struct Response: Encodable {
+  let count: Int
+  let displays: [Int]
+}
+
+let count = max(NSScreen.screens.count, 1)
+let displays = Array(1...count)
+
+let response = Response(count: count, displays: displays)
+let encoder = JSONEncoder()
+encoder.outputFormatting = [.sortedKeys]
+
+if let data = try? encoder.encode(response),
+   let json = String(data: data, encoding: .utf8) {
+  print(json)
+} else {
+  fputs("{\"count\":\(count)}\n", stderr)
+  exit(1)
+}

package/dist/template/.opencode/skill/screenshot/scripts/macos_permissions.swift

@@ -0,0 +1,40 @@
+import CoreGraphics
+import Foundation
+
+struct Status: Encodable {
+  let screenCapture: Bool
+  let requested: Bool
+}
+
+let shouldRequest = CommandLine.arguments.contains("--request")
+
+@available(macOS 10.15, *)
+func screenCaptureGranted(request: Bool) -> Bool {
+  if CGPreflightScreenCaptureAccess() {
+    return true
+  }
+  if request {
+    _ = CGRequestScreenCaptureAccess()
+    return CGPreflightScreenCaptureAccess()
+  }
+  return false
+}
+
+let granted: Bool
+if #available(macOS 10.15, *) {
+  granted = screenCaptureGranted(request: shouldRequest)
+} else {
+  granted = true
+}
+
+let status = Status(screenCapture: granted, requested: shouldRequest)
+let encoder = JSONEncoder()
+encoder.outputFormatting = [.sortedKeys]
+
+if let data = try? encoder.encode(status),
+   let json = String(data: data, encoding: .utf8) {
+  print(json)
+} else {
+  fputs("{\"requested\":\(shouldRequest),\"screenCapture\":\(granted)}\n", stderr)
+  exit(1)
+}

package/dist/template/.opencode/skill/screenshot/scripts/macos_window_info.swift

@@ -0,0 +1,126 @@
+import AppKit
+import CoreGraphics
+import Foundation
+
+struct Bounds: Encodable {
+  let x: Int
+  let y: Int
+  let width: Int
+  let height: Int
+}
+
+struct WindowInfo: Encodable {
+  let id: Int
+  let owner: String
+  let name: String
+  let layer: Int
+  let bounds: Bounds
+  let area: Int
+}
+
+struct Response: Encodable {
+  let count: Int
+  let selected: WindowInfo?
+  let windows: [WindowInfo]?
+}
+
+func value(for flag: String) -> String? {
+  guard let idx = CommandLine.arguments.firstIndex(of: flag) else {
+    return nil
+  }
+  let next = CommandLine.arguments.index(after: idx)
+  guard next < CommandLine.arguments.endIndex else {
+    return nil
+  }
+  return CommandLine.arguments[next]
+}
+
+let frontmostFlag = CommandLine.arguments.contains("--frontmost")
+let explicitApp = value(for: "--app")
+let frontmostName = frontmostFlag ? NSWorkspace.shared.frontmostApplication?.localizedName : nil
+if frontmostFlag && frontmostName == nil {
+  fputs("{\"count\":0}\n", stderr)
+  exit(1)
+}
+let appFilter = (explicitApp ?? frontmostName)?.lowercased()
+let nameFilter = value(for: "--window-name")?.lowercased()
+let includeList = CommandLine.arguments.contains("--list")
+
+let options: CGWindowListOption = [.optionOnScreenOnly, .excludeDesktopElements]
+guard let raw = CGWindowListCopyWindowInfo(options, kCGNullWindowID) as? [[String: Any]] else {
+  fputs("{\"count\":0}\n", stderr)
+  exit(1)
+}
+
+var exactMatches: [WindowInfo] = []
+var partialMatches: [WindowInfo] = []
+exactMatches.reserveCapacity(raw.count)
+partialMatches.reserveCapacity(raw.count)
+
+for entry in raw {
+  guard let owner = entry[kCGWindowOwnerName as String] as? String else { continue }
+  let ownerLower = owner.lowercased()
+  if let appFilter, !ownerLower.contains(appFilter) { continue }
+
+  let name = (entry[kCGWindowName as String] as? String) ?? ""
+  if let nameFilter, !name.lowercased().contains(nameFilter) { continue }
+
+  guard let number = entry[kCGWindowNumber as String] as? Int else { continue }
+  let layer = (entry[kCGWindowLayer as String] as? Int) ?? 0
+
+  guard let boundsDict = entry[kCGWindowBounds as String] as? [String: Any] else { continue }
+  let x = Int((boundsDict["X"] as? Double) ?? 0)
+  let y = Int((boundsDict["Y"] as? Double) ?? 0)
+  let width = Int((boundsDict["Width"] as? Double) ?? 0)
+  let height = Int((boundsDict["Height"] as? Double) ?? 0)
+  if width <= 0 || height <= 0 { continue }
+
+  let bounds = Bounds(x: x, y: y, width: width, height: height)
+  let area = width * height
+  let info = WindowInfo(id: number, owner: owner, name: name, layer: layer, bounds: bounds, area: area)
+  if let appFilter, ownerLower == appFilter {
+    exactMatches.append(info)
+  } else {
+    partialMatches.append(info)
+  }
+}
+
+let windows: [WindowInfo]
+if appFilter != nil && !exactMatches.isEmpty {
+  windows = exactMatches
+} else {
+  windows = partialMatches
+}
+
+func rank(_ window: WindowInfo) -> (Int, Int) {
+  // Prefer normal-layer windows, then larger area.
+  let layerScore = window.layer == 0 ? 0 : 1
+  return (layerScore, -window.area)
+}
+
+let ordered: [WindowInfo]
+if frontmostFlag {
+  ordered = windows
+} else {
+  ordered = windows.sorted { rank($0) < rank($1) }
+}
+let selected = ordered.first
+
+let list: [WindowInfo]?
+if includeList {
+  list = ordered
+} else {
+  list = nil
+}
+
+let response = Response(count: windows.count, selected: selected, windows: list)
+let encoder = JSONEncoder()
+encoder.outputFormatting = [.sortedKeys]
+
+if let data = try? encoder.encode(response),
+   let json = String(data: data, encoding: .utf8) {
+  print(json)
+} else {
+  fputs("{\"count\":\(windows.count)}\n", stderr)
+  exit(1)
+}

package/dist/template/.opencode/skill/screenshot/scripts/take_screenshot.ps1

@@ -0,0 +1,163 @@
+param(
+  [string]$Path,
+  [ValidateSet("default", "temp")][string]$Mode = "default",
+  [string]$Format = "png",
+  [string]$Region,
+  [switch]$ActiveWindow,
+  [int]$WindowHandle
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+function Get-Timestamp {
+  Get-Date -Format "yyyy-MM-dd_HH-mm-ss"
+}
+
+function Get-DefaultDirectory {
+  $home = [Environment]::GetFolderPath("UserProfile")
+  $pictures = Join-Path $home "Pictures"
+  $screenshots = Join-Path $pictures "Screenshots"
+  if (Test-Path $screenshots) { return $screenshots }
+  if (Test-Path $pictures) { return $pictures }
+  return $home
+}
+
+function New-DefaultFilename {
+  param([string]$Prefix)
+  if (-not $Prefix) { $Prefix = "screenshot" }
+  "$Prefix-$(Get-Timestamp).$Format"
+}
+
+function Resolve-OutputPath {
+  if ($Path) {
+    $expanded = [Environment]::ExpandEnvironmentVariables($Path)
+    $homeDir = [Environment]::GetFolderPath("UserProfile")
+    if ($expanded -eq "~") {
+      $expanded = $homeDir
+    } elseif ($expanded.StartsWith("~/") -or $expanded.StartsWith("~\\")) {
+      $expanded = Join-Path $homeDir $expanded.Substring(2)
+    }
+    $full = [System.IO.Path]::GetFullPath($expanded)
+    if ((Test-Path $full) -and (Get-Item $full).PSIsContainer) {
+      $full = Join-Path $full (New-DefaultFilename "")
+    } elseif (($expanded.EndsWith("\") -or $expanded.EndsWith("/")) -and -not (Test-Path $full)) {
+      New-Item -ItemType Directory -Path $full -Force | Out-Null
+      $full = Join-Path $full (New-DefaultFilename "")
+    } elseif ([System.IO.Path]::GetExtension($full) -eq "") {
+      $full = "$full.$Format"
+    }
+    $parent = Split-Path -Parent $full
+    if ($parent) {
+      New-Item -ItemType Directory -Path $parent -Force | Out-Null
+    }
+    return $full
+  }
+
+  if ($Mode -eq "temp") {
+    $tmp = [System.IO.Path]::GetTempPath()
+    return Join-Path $tmp (New-DefaultFilename "codex-shot")
+  }
+
+  $dest = Get-DefaultDirectory
+  return Join-Path $dest (New-DefaultFilename "")
+}
+
+function Parse-Region {
+  if (-not $Region) { return $null }
+  $parts = $Region.Split(",") | ForEach-Object { $_.Trim() }
+  if ($parts.Length -ne 4) {
+    throw "Region must be x,y,w,h"
+  }
+  $values = $parts | ForEach-Object {
+    $out = 0
+    if (-not [int]::TryParse($_, [ref]$out)) {
+      throw "Region values must be integers"
+    }
+    $out
+  }
+  if ($values[2] -le 0 -or $values[3] -le 0) {
+    throw "Region width and height must be positive"
+  }
+  return $values
+}
+
+if ($Region -and $ActiveWindow) {
+  throw "Choose either -Region or -ActiveWindow"
+}
+if ($Region -and $WindowHandle) {
+  throw "Choose either -Region or -WindowHandle"
+}
+if ($ActiveWindow -and $WindowHandle) {
+  throw "Choose either -ActiveWindow or -WindowHandle"
+}
+
+$regionValues = Parse-Region
+$outputPath = Resolve-OutputPath
+
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+$imageFormat = switch ($Format.ToLowerInvariant()) {
+  "png" { [System.Drawing.Imaging.ImageFormat]::Png }
+  "jpg" { [System.Drawing.Imaging.ImageFormat]::Jpeg }
+  "jpeg" { [System.Drawing.Imaging.ImageFormat]::Jpeg }
+  "bmp" { [System.Drawing.Imaging.ImageFormat]::Bmp }
+  default { throw "Unsupported format: $Format" }
+}
+
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public static class NativeMethods {
+  [StructLayout(LayoutKind.Sequential)]
+  public struct RECT {
+    public int Left;
+    public int Top;
+    public int Right;
+    public int Bottom;
+  }
+
+  [DllImport("user32.dll")]
+  public static extern IntPtr GetForegroundWindow();
+
+  [DllImport("user32.dll")]
+  public static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
+}
+"@
+
+if ($regionValues) {
+  $x = $regionValues[0]
+  $y = $regionValues[1]
+  $w = $regionValues[2]
+  $h = $regionValues[3]
+  $bounds = New-Object System.Drawing.Rectangle($x, $y, $w, $h)
+} elseif ($ActiveWindow -or $WindowHandle) {
+  $handle = if ($WindowHandle) { [IntPtr]$WindowHandle } else { [NativeMethods]::GetForegroundWindow() }
+  $rect = New-Object NativeMethods+RECT
+  if (-not [NativeMethods]::GetWindowRect($handle, [ref]$rect)) {
+    throw "Failed to get window bounds"
+  }
+  $width = $rect.Right - $rect.Left
+  $height = $rect.Bottom - $rect.Top
+  $bounds = New-Object System.Drawing.Rectangle($rect.Left, $rect.Top, $width, $height)
+} else {
+  $vs = [System.Windows.Forms.SystemInformation]::VirtualScreen
+  $bounds = New-Object System.Drawing.Rectangle($vs.Left, $vs.Top, $vs.Width, $vs.Height)
+}
+
+$bitmap = New-Object System.Drawing.Bitmap($bounds.Width, $bounds.Height)
+$graphics = [System.Drawing.Graphics]::FromImage($bitmap)
+
+try {
+  $source = New-Object System.Drawing.Point($bounds.Left, $bounds.Top)
+  $target = [System.Drawing.Point]::Empty
+  $size = New-Object System.Drawing.Size($bounds.Width, $bounds.Height)
+  $graphics.CopyFromScreen($source, $target, $size)
+  $bitmap.Save($outputPath, $imageFormat)
+} finally {
+  $graphics.Dispose()
+  $bitmap.Dispose()
+}
+
+Write-Output $outputPath