@laitszkin/apollo-toolkit 2.0.0

package/review-codebases/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yamiyorunoshura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/review-codebases/README.md

@@ -0,0 +1,67 @@
+# Review Codebases
+
+A repository-wide code review skill that reads the whole codebase, prioritizes architecture findings ahead of lower-level issues, and publishes one GitHub issue per confirmed finding.
+
+## What this skill provides
+
+- Full-repository review guidance instead of patch-level review only.
+- A strict review ladder: architecture first, code quality second, edge cases last.
+- A clear evidence bar so only confirmed findings are escalated.
+- Deterministic issue publication through the `open-github-issue` dependency skill.
+
+## Repository structure
+
+- `SKILL.md`: Main review workflow, prioritization rules, and output contract.
+- `agents/openai.yaml`: Agent interface metadata and default prompt.
+- Dependency skill: `open-github-issue` for publishing one GitHub issue per confirmed finding.
+
+## Installation
+
+1. Clone this repository.
+2. Copy this folder to your Codex skills directory:
+
+```bash
+mkdir -p "$CODEX_HOME/skills"
+cp -R review-codebases "$CODEX_HOME/skills/review-codebases"
+```
+
+## Usage
+
+Invoke the skill in your prompt:
+
+```text
+Use $review-codebases to read this repository end to end, prioritize architecture problems first, and publish one GitHub issue per confirmed finding.
+```
+
+## Review order
+
+1. Architecture and system design
+2. Code quality and maintainability
+3. Edge cases and robustness
+
+The skill only advances to the next tier when the previous tier has no confirmed findings.
+
+## GitHub issue handoff
+
+For each confirmed finding, delegate publication to `$open-github-issue` with:
+
+- a tier-specific title prefix
+- repository evidence and impact in `problem-description`
+- file references and causal reasoning in `suspected-cause`
+- reproduction conditions when known
+
+If issue publication is unavailable, return draft issue content instead of switching to an ad-hoc publishing path.
+
+## Output expectations
+
+The skill is designed to return:
+
+1. Codebase coverage and explicit exclusions
+2. Review tier reached and why lower tiers were skipped
+3. Confirmed findings with evidence, impact, and confidence
+4. GitHub issue publication status for each finding
+5. Deferred follow-up when higher-tier issues stop deeper review
+
+## License
+
+MIT. See `LICENSE`.

package/review-codebases/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: review-codebases
+description: Repository-wide code review workflow that requires reading the full codebase before judging, prioritizes architecture findings over implementation details, and publishes one GitHub issue per confirmed finding through open-github-issue. Use when users ask for a code review, repository audit, architecture review, maintainability review, or complete codebase inspection.
+---
+
+# Review Codebases
+
+## Dependencies
+
+- Required: none.
+- Conditional: `open-github-issue` when confirmed findings should be tracked as GitHub issues.
+- Optional: none.
+- Fallback: If publication is needed and `open-github-issue` is unavailable, return draft issue bodies instead of inventing another publisher.
+
+## Standards
+
+- Evidence: Read the full human-authored repository before judging and cite concrete files for every finding.
+- Execution: Review architecture first, code quality second, and edge cases last, stopping when a higher-priority tier has confirmed findings.
+- Quality: Prefer root-cause findings over scattered symptoms, merge duplicates, and keep hypotheses out of published results.
+- Output: Return coverage, review tier reached, confirmed findings, publication status, and deferred lower-tier follow-up.
+
+## Overview
+
+Use this skill to review an entire repository before making judgments.
+
+The review order is strict:
+
+1. Architecture and system design
+2. Code quality and maintainability
+3. Edge cases and robustness gaps
+
+Only continue to the next level when the current level has no confirmed findings.
+
+## Core rules
+
+- Read the full repository before judging any design or implementation choice.
+- Inspect every human-authored file that affects behavior: source code, tests, build scripts, configuration, migrations, and key docs.
+- For generated, vendored, or snapshot files, verify what they are first; exclude them from deep review only when that status is clear, and list those exclusions explicitly.
+- Do not speculate. Every finding must cite concrete files and causal reasoning.
+- Prefer root-cause findings over scattered symptoms or style nits.
+- Merge duplicate symptoms into one finding when they come from the same underlying issue.
+
+## Workflow
+
+1. Map the repository
+   - List top-level directories and identify entrypoints, domain modules, test suites, configuration, scripts, and generated/vendor areas.
+   - Record any files or folders excluded from deep review and why.
+2. Read the whole codebase
+   - Read all relevant human-authored files end to end.
+   - Build a repository-wide model of boundaries, data flow, ownership, invariants, and failure handling.
+3. Review architecture first
+   - Check module boundaries, layering, hidden coupling, circular dependencies, duplicated workflows, leaky abstractions, ownership confusion, and inconsistent domain models.
+   - If any confirmed architecture findings exist, stop the lower-level review and report only architecture findings.
+4. Review code quality second
+   - Run this step only when there are no architecture findings.
+   - Check readability, duplication, dead code, error handling, unsafe state changes, unclear contracts, missing tests around critical logic, and maintainability risks.
+   - If any confirmed code-quality findings exist, stop before edge-case review and report only these findings.
+5. Review edge cases last
+   - Run this step only when there are no architecture or code-quality findings.
+   - Check null or empty inputs, boundary values, partial failures, retries, concurrency, ordering assumptions, idempotency, and invalid state transitions.
+6. Publish each confirmed finding
+   - Invoke `open-github-issue` once per finding.
+   - Use a tier-specific title prefix:
+     - `[Architecture] <short finding>`
+     - `[Code Quality] <short finding>`
+     - `[Edge Case] <short finding>`
+   - Pass these fields to the dependency skill:
+     - `title`
+     - `problem-description`: symptom, impact, and repository evidence
+     - `suspected-cause`: file references, causal chain, and confidence
+     - `reproduction`: concrete trigger or conditions when known; otherwise leave empty
+     - `repo`: target repository in `owner/repo` format when known
+
+## Evidence standard
+
+Each finding must include:
+
+- affected files or modules
+- why the current design or code is problematic
+- impact on correctness, maintenance, performance, or future change safety
+- confidence level with a short reason
+
+If evidence is incomplete, keep it as a hypothesis and do not publish a GitHub issue for it.
+
+## Output format
+
+Use this structure in responses:
+
+1. Codebase coverage
+   - reviewed areas
+   - explicit exclusions
+2. Review tier reached
+   - architecture / code quality / edge cases
+   - why lower tiers were skipped, if applicable
+3. Confirmed findings
+   - title
+   - affected files
+   - evidence and reasoning
+   - impact
+   - confidence
+4. GitHub issue publication status
+   - publication mode (`gh-cli` / `github-token` / `draft-only`)
+   - created issue URL or draft output per finding
+5. Deferred follow-up
+   - list lower-tier checks that were intentionally not performed because a higher-tier issue already exists
+
+## Resources
+
+- Dependency skill: `open-github-issue` for deterministic GitHub issue publication with auth fallback and README language detection.

package/review-codebases/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Review Codebases"
+  short_description: "Review a whole repository and publish findings"
+  default_prompt: "Use $review-codebases to read the full repository, prioritize architecture findings before lower-level issues, and publish one GitHub issue per confirmed finding through $open-github-issue."

package/scripts/install_skills.ps1

@@ -0,0 +1,283 @@
+param(
+  [Parameter(ValueFromRemainingArguments = $true)]
+  [string[]]$Modes
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+function Show-Usage {
+  @"
+Usage:
+  ./scripts/install_skills.ps1 [codex|openclaw|trae|all]...
+
+Modes:
+  codex     Install links into ~/.codex/skills
+  openclaw  Install links into ~/.openclaw/workspace*/skills
+  trae      Install links into ~/.trae/skills
+  all       Install all supported targets
+
+Optional environment overrides:
+  CODEX_SKILLS_DIR   Override codex skills destination path
+  OPENCLAW_HOME      Override openclaw home path
+  TRAE_SKILLS_DIR    Override trae skills destination path
+  APOLLO_TOOLKIT_HOME Override local install path used when repo root is unavailable
+  APOLLO_TOOLKIT_REPO_URL Override git repository URL used when repo root is unavailable
+"@
+}
+
+$ToolkitRepoUrl = if ($env:APOLLO_TOOLKIT_REPO_URL) { $env:APOLLO_TOOLKIT_REPO_URL } else { "https://github.com/LaiTszKin/apollo-toolkit.git" }
+$ToolkitHome = if ($env:APOLLO_TOOLKIT_HOME) { $env:APOLLO_TOOLKIT_HOME } else { Join-Path $HOME ".apollo-toolkit" }
+
+function Show-Banner {
+  @"
++------------------------------------------+
+|              Apollo Toolkit              |
+|      npm installer and skill linker      |
++------------------------------------------+
+"@
+}
+
+function Test-RepoRoot {
+  param([string]$Path)
+
+  if ([string]::IsNullOrWhiteSpace($Path) -or -not (Test-Path -LiteralPath $Path -PathType Container)) {
+    return $false
+  }
+
+  $dirs = Get-ChildItem -Path $Path -Directory -ErrorAction SilentlyContinue
+  foreach ($dir in $dirs) {
+    if (Test-Path -LiteralPath (Join-Path $dir.FullName "SKILL.md") -PathType Leaf) {
+      return $true
+    }
+  }
+
+  return $false
+}
+
+function Bootstrap-RepoIfNeeded {
+  if (Test-Path -LiteralPath (Join-Path $ToolkitHome ".git") -PathType Container) {
+    git -C $ToolkitHome pull --ff-only | Out-Null
+  }
+  else {
+    if (Test-Path -LiteralPath $ToolkitHome) {
+      Remove-Item -LiteralPath $ToolkitHome -Force -Recurse
+    }
+    git clone --depth 1 $ToolkitRepoUrl $ToolkitHome | Out-Null
+  }
+}
+
+$scriptPath = $MyInvocation.MyCommand.Path
+$candidateRepoRoot = $null
+
+if (-not [string]::IsNullOrWhiteSpace($scriptPath)) {
+  $scriptDir = Split-Path -Parent $scriptPath
+  $candidateRepoRoot = Split-Path -Parent $scriptDir
+}
+
+if (Test-RepoRoot -Path $candidateRepoRoot) {
+  $RepoRoot = $candidateRepoRoot
+}
+elseif (Test-RepoRoot -Path (Get-Location).Path) {
+  $RepoRoot = (Get-Location).Path
+}
+else {
+  Bootstrap-RepoIfNeeded
+  $RepoRoot = $ToolkitHome
+}
+
+function Get-SkillPaths {
+  $dirs = Get-ChildItem -Path $RepoRoot -Directory | Sort-Object Name
+  $skills = @()
+
+  foreach ($dir in $dirs) {
+    if (Test-Path -LiteralPath (Join-Path $dir.FullName "SKILL.md") -PathType Leaf) {
+      $skills += $dir.FullName
+    }
+  }
+
+  if ($skills.Count -eq 0) {
+    throw "No skill folders found in: $RepoRoot"
+  }
+
+  return $skills
+}
+
+function Add-ModeOnce {
+  param(
+    [System.Collections.Generic.List[string]]$Selected,
+    [string]$Mode
+  )
+
+  if (-not $Selected.Contains($Mode)) {
+    $Selected.Add($Mode)
+  }
+}
+
+function Resolve-Modes {
+  param([string[]]$Requested)
+
+  $selected = [System.Collections.Generic.List[string]]::new()
+
+  if ($Requested.Count -eq 0) {
+    Show-Banner
+    Write-Host ""
+    Write-Host "Select install options (comma-separated):"
+    Write-Host "1) codex (~/.codex/skills)"
+    Write-Host "2) openclaw (~/.openclaw/workspace*/skills)"
+    Write-Host "3) trae (~/.trae/skills)"
+    Write-Host "4) all"
+    $inputValue = Read-Host "Enter choice(s) [1-4]"
+
+    foreach ($rawChoice in ($inputValue -split ",")) {
+      $choice = $rawChoice.Trim()
+      switch ($choice) {
+        "1" { Add-ModeOnce -Selected $selected -Mode "codex" }
+        "2" { Add-ModeOnce -Selected $selected -Mode "openclaw" }
+        "3" { Add-ModeOnce -Selected $selected -Mode "trae" }
+        "4" {
+          Add-ModeOnce -Selected $selected -Mode "codex"
+          Add-ModeOnce -Selected $selected -Mode "openclaw"
+          Add-ModeOnce -Selected $selected -Mode "trae"
+        }
+        default {
+          throw "Invalid choice: $choice"
+        }
+      }
+    }
+  }
+  else {
+    foreach ($mode in $Requested) {
+      switch ($mode.ToLowerInvariant()) {
+        "codex" { Add-ModeOnce -Selected $selected -Mode "codex" }
+        "openclaw" { Add-ModeOnce -Selected $selected -Mode "openclaw" }
+        "trae" { Add-ModeOnce -Selected $selected -Mode "trae" }
+        "all" {
+          Add-ModeOnce -Selected $selected -Mode "codex"
+          Add-ModeOnce -Selected $selected -Mode "openclaw"
+          Add-ModeOnce -Selected $selected -Mode "trae"
+        }
+        default {
+          Show-Usage
+          throw "Invalid mode: $mode"
+        }
+      }
+    }
+  }
+
+  if ($selected.Count -eq 0) {
+    throw "No install option selected."
+  }
+
+  return $selected
+}
+
+function Remove-PathForce {
+  param([string]$Target)
+
+  if (Test-Path -LiteralPath $Target) {
+    Remove-Item -LiteralPath $Target -Force -Recurse
+  }
+}
+
+function Link-Skill {
+  param(
+    [string]$Source,
+    [string]$TargetRoot
+  )
+
+  $name = Split-Path -Path $Source -Leaf
+  $target = Join-Path $TargetRoot $name
+
+  New-Item -ItemType Directory -Path $TargetRoot -Force | Out-Null
+  Remove-PathForce -Target $target
+
+  try {
+    New-Item -Path $target -ItemType SymbolicLink -Target $Source -Force | Out-Null
+    Write-Host "[linked] $target -> $Source"
+  }
+  catch {
+    # Fallback for environments where symlink permission is restricted.
+    New-Item -Path $target -ItemType Junction -Target $Source -Force | Out-Null
+    Write-Host "[linked-junction] $target -> $Source"
+  }
+}
+
+function Install-Codex {
+  param([string[]]$SkillPaths)
+
+  $target = if ($env:CODEX_SKILLS_DIR) {
+    $env:CODEX_SKILLS_DIR
+  }
+  else {
+    Join-Path $HOME ".codex/skills"
+  }
+
+  Write-Host "Installing to codex: $target"
+  foreach ($src in $SkillPaths) {
+    Link-Skill -Source $src -TargetRoot $target
+  }
+}
+
+function Install-OpenClaw {
+  param([string[]]$SkillPaths)
+
+  $openclawHome = if ($env:OPENCLAW_HOME) {
+    $env:OPENCLAW_HOME
+  }
+  else {
+    Join-Path $HOME ".openclaw"
+  }
+
+  if (-not (Test-Path -LiteralPath $openclawHome -PathType Container)) {
+    throw "OpenClaw home not found: $openclawHome"
+  }
+
+  $workspaces = Get-ChildItem -Path $openclawHome -Directory -Filter "workspace*" | Sort-Object Name
+  if ($workspaces.Count -eq 0) {
+    throw "No workspace directories found under: $openclawHome"
+  }
+
+  foreach ($workspace in $workspaces) {
+    $skillsDir = Join-Path $workspace.FullName "skills"
+    Write-Host "Installing to openclaw workspace: $skillsDir"
+    foreach ($src in $SkillPaths) {
+      Link-Skill -Source $src -TargetRoot $skillsDir
+    }
+  }
+}
+
+function Install-Trae {
+  param([string[]]$SkillPaths)
+
+  $target = if ($env:TRAE_SKILLS_DIR) {
+    $env:TRAE_SKILLS_DIR
+  }
+  else {
+    Join-Path $HOME ".trae/skills"
+  }
+
+  Write-Host "Installing to trae: $target"
+  foreach ($src in $SkillPaths) {
+    Link-Skill -Source $src -TargetRoot $target
+  }
+}
+
+if ($Modes.Count -gt 0 -and ($Modes[0] -eq "-h" -or $Modes[0] -eq "--help")) {
+  Show-Usage
+  exit 0
+}
+
+$selectedModes = Resolve-Modes -Requested $Modes
+$skillPaths = Get-SkillPaths
+
+foreach ($mode in $selectedModes) {
+  switch ($mode) {
+    "codex" { Install-Codex -SkillPaths $skillPaths }
+    "openclaw" { Install-OpenClaw -SkillPaths $skillPaths }
+    "trae" { Install-Trae -SkillPaths $skillPaths }
+    default { throw "Unknown mode: $mode" }
+  }
+}
+
+Write-Host "Done."