Skip to content
Back to search

atlas-prd-taskmaster

MarketplaceWorks with Claude CodeGitHub

Marketplace manifest for the prd plugin (the Atlas engine). Add with: /plugin marketplace add anombyte93/prd-taskmaster

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/anombyte93--prd-taskmaster/badge.svg)](/listings/anombyte93--prd-taskmaster)

HTML

<a href="/listings/anombyte93--prd-taskmaster"><img src="/api/listings/anombyte93--prd-taskmaster/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

90 seconds to your first run.

Path 1 — one-liner (recommended)

curl -fsSL https://atlas-ai.au/install | bash
# installs the skill + prd_taskmaster package
# TaskMaster install is optional — unlocks the TaskMaster backend

Path 2 — Claude Code plugin

# add the marketplace, then install the plugin
/plugin marketplace add anombyte93/prd-taskmaster
/plugin install prd

# optional — unlocks the TaskMaster backend
npm install -g task-master-ai

First run

Open any project in Claude Code and type:

/prd:atlas      (or /prd:go, or just say: "I want to build …")

Requires Python 3.11+ and Linux / macOS / WSL. The free engine needs **no paid API key** — it uses the model CLIs you already have; an optional local research proxy can be plugged in (bring your own — not bundled). npm installs run a `postinstall` step that pip-installs the MCP server's Python deps (non-fatal warning if pip is unavailable).

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 16 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
  3. "name": "atlas-prd-taskmaster",
  4. "description": "Marketplace manifest for the prd plugin (the Atlas engine). Add with: /plugin marketplace add anombyte93/prd-taskmaster",
  5. "owner": {
  6. "name": "Atlas-X-AI"
  7. },
  8. "plugins": [
  9. {
  10. "name": "prd",
  11. "description": "Zero-config goal-to-tasks engine for Claude Code, plugin-native rebuild with CDD-verified execution",
  12. "source": "./",
  13. "category": "development"
  14. }
  15. ]
  16. }
README.md · README · 230 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Turn any goal into shipped code.
  2. **prd-taskmaster** by [Atlas AI](https://atlas-ai.au) is an open-source engine for Claude Code
  3. that takes a one-line goal, interviews you like a senior PM, writes a **graded,
  4. placeholder-proof PRD**, compiles it into a **dependency-ordered task graph**, and executes every
  5. task with **verification evidence** — so "done" means proven, not claimed.
  6. Free and MIT, forever.
  7. > ⚠️ **Pre-alpha — under active development.** Atlas was recently consolidated into this engine
  8. > and the newer systems (fleet orchestration, backend abstraction, token economy) have **not been
  9. > fully tested in the wild yet**. Expect rough edges and breaking changes between releases, pin a
  10. > version if you need stability, and please [report what breaks](https://github.com/anombyte93/prd-taskmaster/issues).
  11. > No warranty beyond the MIT license. **Atlas Pro is not generally available** — it is a private
  12. > pilot (see below).
  13. Atlas has four structural moats:
  14. - **cross-vendor fleet** — Claude, Codex, and Gemini run as separate quota pools instead of one
  15. brittle model lane.
  16. - **Engine-enforced unfakable gates** — `validate-tasks`, evidence checks, and `SHIP_CHECK_OK`
  17. make completion a deterministic state, not a claim.
  18. - **persistent vendor-neutral `tasks.json`** — your PRD, task graph, and execution state stay as
  19. plain repo files that survive vendor swaps.
  20. - **token-economy cost ledger** — every orchestrated model call records routing, exit, latency,
  21. and escalation so cheap models do cheap work and expensive models justify themselves.
  22. **Atlas speaks TaskMaster natively — but doesn't need it.** Existing TaskMaster projects get a
  23. migration funnel: install `task-master-ai` only when you want the TaskMaster backend, while the
  24. native backend keeps the same validated task graph available without that prerequisite.
  25. ```
  26. Grade: GOOD ▰▰▰▰▰▰▰▰▱▱ 49/57 (86%) · 0 placeholders · 14 tasks parsed
  27. ```
  28. [![status: pre-alpha](https://img.shields.io/badge/status-pre--alpha-orange.svg)](#project-status)
  29. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
  30. [![GitHub stars](https://img.shields.io/github/stars/anombyte93/prd-taskmaster)](https://github.com/anombyte93/prd-taskmaster/stargazers)
  31. [![works with](https://img.shields.io/badge/works_with-Claude%20%C2%B7%20Codex%20%C2%B7%20Gemini-8A2BE2)](https://atlas-ai.au)
  32. [![free engine](https://img.shields.io/badge/engine-MIT%20free%20forever-brightgreen)](#whats-open-whats-not)
  33. ---
  34. ## How it works
  35. ```
  36. goal → discovery interview → graded PRD → dependency-ordered task graph → verified execution
  37. ```
  38. 1. **Preflight** — detects your environment (native backend, optional TaskMaster backend, model CLIs, research) and configures it. Zero setup questions.
  39. 2. **Discovery** — an adaptive, one-question-at-a-time interview captures your real constraints.
  40. 3. **Generate** — writes a PRD, scores it against deterministic quality checks (letter grade), then parses it into a task graph with complexity scores and full subtask coverage.
  41. 4. **Handoff** — detects what you have installed and recommends one execution mode.
  42. 5. **Execute** — a CDD-gated loop implements each task and proves it with evidence, ending in a deterministic `SHIP_CHECK_OK` token.
  43. ---
  44. ## Quickstart
  45. 90 seconds to your first run.
  46. ### Path 1 — one-liner (recommended)
  47. ```bash
  48. curl -fsSL https://atlas-ai.au/install | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 65 on GitHub
  49. # installs the skill + prd_taskmaster package
  50. # TaskMaster install is optional — unlocks the TaskMaster backend
  51. ```
  52. ### Path 2 — Claude Code plugin
  53. ```bash
  54. # add the marketplace, then install the plugin
  55. /plugin marketplace add anombyte93/prd-taskmaster
  56. /plugin install prd
  57. # optional — unlocks the TaskMaster backend
  58. npm install -g task-master-ai
  59. ```
  60. ### First run
  61. Open any project in Claude Code and type:
  62. ```
  63. /prd:atlas (or /prd:go, or just say: "I want to build …")
  64. ```
  65. Requires Python 3.11+ and Linux / macOS / WSL. The free engine needs **no paid API key** — it
  66. uses the model CLIs you already have; an optional local research proxy can be plugged in
  67. (bring your own — not bundled). npm installs run a `postinstall` step that pip-installs the
  68. MCP server's Python deps (non-fatal warning if pip is unavailable).
  69. ---
  70. ## What "verified" means
  71. Most AI coding tools tell you a task is done. This one makes "done" provable:
  72. - **Graded PRDs.** Every spec is scored against deterministic checks (EXCELLENT / GOOD / ACCEPTABLE / NEEDS WORK). Placeholders (`TBD`, `{{...}}`, `TODO` — bare or bracketed) are a hard fail: the grade floors to NEEDS WORK and `validate-prd` exits non-zero.
  73. - **A real task graph.** Requirements become backend-neutral `tasks.json` tasks with dependencies, complexity scores, and full subtask coverage — not a flat checklist.
  74. - **Evidence-gated execution.** Each task is implemented and must produce execution evidence before it counts as done.
  75. - **A completion token you can trust.** `SHIP_CHECK_OK` is emitted only when every gate passes — and a single non-zero `Exit status` in any evidence file blocks it. It is structurally hard to fake. (One escape hatch exists for incident recovery: an explicit admin override flag that is audit-logged and marks the token `[OVERRIDE]` on stdout — never silent.)
  76. ```
  77. ┌─ atlas ── PHASE 3/4: GENERATE ─────────────────────────────┐
  78. │ Grade: GOOD ▰▰▰▰▰▰▰▰▱▱ 49/57 (86%) │
  79. │ ✓ 11 checks passed structure · testability · metrics │
  80. │ ⚠ 2 warnings (quoted + located, not just counted) │
  81. │ ✓ 0 placeholders (TBD/TODO/{{...}} scan clean) │
  82. │ Tasks: 14 parsed · 52 subtasks · dependencies mapped │
  83. └────────────────────────────────────────────────────────────┘
  84. ```
  85. ---
  86. ## Project status
  87. **Pre-alpha.** The deterministic core — graded PRD validation, the task graph, the ship-check
  88. gate, the CLI — is covered by ~300 tests and is the most stable surface. The newer systems
  89. around it (cross-vendor fleet, backend abstraction, the token-economy ledger, the bundled Pro
  90. MCPs) are **recently built and not yet battle-tested**; their numbers (e.g. cost savings) are
  91. verified-rate *estimates*, not measured guarantees (see
  92. [`docs/product/MODEL-ECONOMY.md`](docs/product/MODEL-ECONOMY.md)). Expect breaking changes
  93. between releases; pin a version for stability. Bug reports and use-case notes are the fastest way
  94. to move it toward stable — [open an issue](https://github.com/anombyte93/prd-taskmaster/issues).
  95. ## Built for the token-shortage era
  96. Every job runs on the cheapest model that can do it — and escalates only when a validator says
  97. it failed. One setting controls how aggressive that is:
  98. ```json
  99. // .atlas-ai/fleet.json
  100. { "token_economy": "conservative" } // or "balanced" (default) / "performance"
  101. ```
  102. Task decomposition and research run through the selected backend. Native mode works without a
  103. TaskMaster install; installing `task-master-ai >= 0.43.0` unlocks TaskMaster's model-agnostic AI
  104. (any API you configure — Anthropic, OpenAI, Perplexity, Gemini, openai-compatible…) and isolated
  105. workdir expansion when that backend is selected. Complexity 2 scaffolding gets a haiku-class
  106. model; the hardest long-running work gets the frontier model; nothing defaults to expensive.
  107. Local telemetry (`economy-report`) shows your real success-rate and latency per model so the
  108. routing gets smarter on YOUR workload — priors and sources in
  109. [`docs/product/MODEL-ECONOMY.md`](docs/product/MODEL-ECONOMY.md).
  110. ## Free vs Atlas Pro
  111. > **Atlas Pro is in private pilot — not generally available and not yet for sale.** Pricing is
  112. > not set. During the pilot, access is granted at our discretion to testers with a strong use
  113. > case (often free). The table shows what Pro *will* add; the Pro-only rows are **experimental and
  114. > not fully tested**. Want in? **[Request pilot access →](https://github.com/anombyte93/prd-taskmaster/discussions)**
  115. > (an on-site signup at `atlas-ai.au/pilot` to be notified at launch is coming).
  116. | | Free (MIT) | Atlas Pro — private pilot |
  117. |---|:---:|:---:|
  118. | Discovery interview (adaptive, one question at a time) | ✓ | ✓ |
  119. | Graded PRD validation + placeholder scan | ✓ | ✓ |
  120. | Dependency-ordered task graph (`tasks.json`) | ✓ | ✓ |
  121. | Verified solo execution — evidence required per task | ✓ | ✓ |
  122. | Model-agnostic: Claude / Codex / Gemini | ✓ | ✓ |
  123. | Parallel research fan-out | ✓ | ✓ |
  124. | **Token economy** — start cheap, escalate only on failure (conservative/balanced/performance) | ✓ | ✓ |
  125. | Optional **TaskMaster backend** expansion — any configured API, isolated workdirs | ✓ | ✓ |
  126. | Local cost telemetry + `economy-report` | ✓ | ✓ |
  127. | Adaptive routing auto-tuning from telemetry | — | ✓ (roadmap) |
  128. | **Atlas Fleet** — parallel waves of isolated workers, checker-gated merges, one final PR | — | ✓ |
  129. | Browser-verification MCP (UI proof, not just logs) | — | ✓ |
  130. | Secrets-vault MCP (keys never in your repo or prompts) | — | ✓ |
  131. | License & priority support | community | ✓ |
  132. The engine is the whole engine — the free tier is **not a demo**. Pro adds the fleet orchestrator
  133. and bundled MCPs (both pilot-stage, not fully tested). [Request pilot access →](https://github.com/anombyte93/prd-taskmaster/discussions)
  134. ---
  135. ## Atlas Fleet (Atlas Pro)
  136. When a build is big enough to want overnight parallelism, **Atlas Fleet** lifts the same engine
  137. from one session to many. It splits your task graph into dependency **waves** of file-disjoint
  138. chunks, spawns model-agnostic workers (Claude / Codex / Gemini) in isolated **git worktrees**,
  139. collects results through a durable inbox rather than trusting an agent's word, and merges waves
  140. sequentially into an integration branch behind a checker gate — never touching `main` until one
  141. final green PR.
  142. It runs entirely on your machine. Your specs and tasks are plain files in your repo, nothing is
  143. held hostage. **Fleet is pilot-stage and not yet hardened** — treat it as a preview.
  144. [Request pilot access →](https://github.com/anombyte93/prd-taskmaster/discussions)
  145. ---
  146. ## What's open, what's not
  147. **Open (MIT, free forever):** discovery, PRD validation, the task graph, and solo verified
  148. execution — the entire engine in this repo. Read every line.
  149. **Closed (Atlas Pro):** the `atlas-launcher` fleet orchestrator and the two bundled MCPs
  150. (browser verification, secrets vault). The engine repo will never require a license key.
  151. ---
  152. ## FAQ
  153. **Will the free engine stay free?** Yes — MIT, and this repo will never require a key.
  154. **What happens if I cancel Pro?** Fleet locks again; everything free keeps working. Your specs
  155. and tasks are plain files in your repo.
  156. **Do I need a paid API key?** No. The engine uses the model CLIs you already have (Claude Code,
  157. Codex, Gemini); an optional local research proxy can be plugged in (bring your own — not bundled).
  158. **Do I need TaskMaster?** No. Atlas speaks TaskMaster natively but doesn't require it —
  159. Native Mode produces the same validated task graph (validate-tasks + enrich-tasks). Installing
  160. `task-master-ai >= 0.43.0` unlocks the TaskMaster backend: Mode B auto-execute and
  161. native-parallel expansion through TaskMaster's 13-provider model layer.
  162. **Which platforms?** Linux, macOS, and WSL. (Native Windows is not supported — the atomic state
  163. machine uses POSIX file locking.)
  164. ---
  165. ## Contributing & License
  166. Issues and PRs welcome — see [CONTRIBUTING.md](CONTRIBUTING.md) and
  167. [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md). Product and UX specifications live in
  168. [`docs/product/`](docs/product/).
  169. The engine is **MIT licensed and will always be** — see [LICENSE](LICENSE). Upgrading from v3?
  170. See [CHANGELOG.md](CHANGELOG.md). v3 remains available via `git checkout v3.0.0`.
install.sh · Bundled script · 490 lines · 3 findings marked
  1. #!/usr/bin/env bash
  2. # ============================================================================
  3. # Universal Claude Code Skill Installer
  4. # ============================================================================
  5. # Usage:
  6. # curl -fsSL https://raw.githubusercontent.com/OWNER/REPO/main/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 6 on GitHub
  7. # bash install.sh # fresh install or upgrade
  8. # bash install.sh --with-taskmaster # also install the optional TaskMaster backend
  9. # bash install.sh --no-taskmaster # skip the optional TaskMaster backend offer
  10. # bash install.sh --check-update # check for newer version only
  11. #
  12. # Customize the variables below for your skill repository.
  13. # ============================================================================
  14. set -euo pipefail
  15. # ---------------------------------------------------------------------------
  16. # Skill Configuration (customize these per-repo)
  17. # ---------------------------------------------------------------------------
  18. REPO_OWNER="anombyte93"
  19. REPO_NAME="prd-taskmaster"
  20. SKILL_NAME="prd-taskmaster"
  21. VERSION="5.3.1"
  22. SKILL_DIR="${SKILL_DIR:-${HOME}/.claude/skills/${SKILL_NAME}}"
  23. ALIAS_NAME="atlas"
  24. ALIAS_DIR="${HOME}/.claude/skills/${ALIAS_NAME}"
  25. TASKMASTER_INSTALL_MODE="ask"
  26. # ---------------------------------------------------------------------------
  27. # Internal constants
  28. # ---------------------------------------------------------------------------
  29. UPDATES_DIR="${HOME}/.config/claude-skills"
  30. UPDATES_FILE="${UPDATES_DIR}/updates.json"
  31. UPDATE_INTERVAL_SECONDS=86400 # 24 hours
  32. GITHUB_API="https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/releases/latest"
  33. CLONE_URL="https://github.com/${REPO_OWNER}/${REPO_NAME}.git"
  34. # ---------------------------------------------------------------------------
  35. # Colors (disabled when piped or in CI)
  36. # ---------------------------------------------------------------------------
  37. if [[ -t 1 ]] && [[ -z "${CI:-}" ]] && [[ -z "${NO_COLOR:-}" ]]; then
  38. RED='\033[0;31m'
  39. GREEN='\033[0;32m'
  40. YELLOW='\033[0;33m'
  41. CYAN='\033[0;36m'
  42. BOLD='\033[1m'
  43. RESET='\033[0m'
  44. else
  45. RED='' GREEN='' YELLOW='' CYAN='' BOLD='' RESET=''
  46. fi
  47. # ---------------------------------------------------------------------------
  48. # Helpers
  49. # ---------------------------------------------------------------------------
  50. info() { printf "${CYAN}[info]${RESET} %s\n" "$*"; }
  51. ok() { printf "${GREEN}[ok]${RESET} %s\n" "$*"; }
  52. warn() { printf "${YELLOW}[warn]${RESET} %s\n" "$*"; }
  53. err() { printf "${RED}[error]${RESET} %s\n" "$*" >&2; }
  54. die() { err "$@"; exit 1; }
  55. cleanup() {
  56. if [[ -n "${TMPDIR_SKILL:-}" ]] && [[ -d "${TMPDIR_SKILL}" ]]; then
  57. rm -rf "${TMPDIR_SKILL}"
  58. fi
  59. }
  60. trap cleanup EXIT
  61. require_cmd() {
  62. command -v "$1" >/dev/null 2>&1 || die "Required command not found: $1"
  63. }
  64. set_taskmaster_install_mode() {
  65. local requested="$1"
  66. if [[ "${TASKMASTER_INSTALL_MODE}" != "ask" ]] && [[ "${TASKMASTER_INSTALL_MODE}" != "${requested}" ]]; then
  67. die "Conflicting TaskMaster backend flags: choose --with-taskmaster or --no-taskmaster"
  68. fi
  69. TASKMASTER_INSTALL_MODE="${requested}"
  70. }
  71. install_taskmaster_backend() {
  72. info "Installing optional task-master-ai package (unlocks the TaskMaster backend)"
  73. if command -v task-master-ai >/dev/null 2>&1; then
  74. ok "TaskMaster backend already available"
  75. return 0
  76. fi
  77. if ! command -v npm >/dev/null 2>&1; then
  78. warn "npm not found; skipping optional TaskMaster backend install"
  79. warn "Atlas native backend remains available"
  80. return 0
  81. fi
  82. if npm install -g task-master-ai; then
  83. ok "Installed optional TaskMaster backend"
  84. else
  85. warn "Optional TaskMaster backend install failed"
  86. warn "Atlas native backend remains available"
  87. fi
  88. }
  89. offer_taskmaster_backend() {
  90. case "${TASKMASTER_INSTALL_MODE}" in
  91. with)
  92. install_taskmaster_backend
  93. ;;
  94. without)
  95. info "Skipping optional TaskMaster backend install (--no-taskmaster)"
  96. ;;
  97. ask)
  98. if [[ ! -t 0 ]]; then
  99. info "Non-interactive shell; skipping optional TaskMaster backend install"
  100. info "Use --with-taskmaster to install task-master-ai when you want the TaskMaster backend"
  101. return 0
  102. fi
  103. local answer
  104. printf "Install optional task-master-ai package (unlocks the TaskMaster backend)? [Y/n] "
  105. read -r answer || answer=""
  106. case "${answer:-Y}" in
  107. Y|y|YES|Yes|yes)
  108. install_taskmaster_backend
  109. ;;
  110. N|n|NO|No|no)
  111. info "Skipping optional TaskMaster backend install"
  112. ;;
  113. *)
  114. warn "Unrecognized answer; skipping optional TaskMaster backend install"
  115. ;;
  116. esac
  117. ;;
  118. esac
  119. }
  120. # ---------------------------------------------------------------------------
  121. # Update check (callable standalone)
  122. # ---------------------------------------------------------------------------
  123. check_update() {
  124. # Respect CI / explicit opt-out
  125. if [[ -n "${CI:-}" ]] || [[ -n "${NO_UPDATE_CHECK:-}" ]]; then
  126. return 0
  127. fi
  128. require_cmd curl
  129. require_cmd date
  130. mkdir -p "${UPDATES_DIR}"
  131. # Throttle: only check once per UPDATE_INTERVAL_SECONDS
  132. if [[ -f "${UPDATES_FILE}" ]]; then
  133. local last_check
  134. last_check=$(python3 -c "
  135. import json, sys
  136. try:
  137. d = json.load(open('${UPDATES_FILE}'))
  138. print(d.get('skills', {}).get('${SKILL_NAME}', {}).get('last_check', 0))
  139. except Exception:
  140. print(0)
  141. " 2>/dev/null || echo 0)
  142. local now
  143. now=$(date +%s)
  144. local elapsed=$(( now - last_check ))
  145. if [[ ${elapsed} -lt ${UPDATE_INTERVAL_SECONDS} ]]; then
  146. # Within cooldown -- read cached result
  147. local cached_latest
  148. cached_latest=$(python3 -c "
  149. import json
  150. try:
  151. d = json.load(open('${UPDATES_FILE}'))
  152. print(d.get('skills', {}).get('${SKILL_NAME}', {}).get('latest', ''))
  153. except Exception:
  154. print('')
  155. " 2>/dev/null || echo "")
  156. if [[ -n "${cached_latest}" ]] && [[ "${cached_latest}" != "${VERSION}" ]]; then
  157. warn "Update available: ${VERSION} -> ${cached_latest}"
  158. info "Run: curl -fsSL https://raw.githubusercontent.com/${REPO_OWNER}/${REPO_NAME}/main/install.sh | bash"
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 179 on GitHub
  159. fi
  160. return 0
  161. fi
  162. fi
  163. # Fetch latest release from GitHub API
  164. local api_response
  165. api_response=$(curl -fsSL --max-time 5 \
  166. -H "Accept: application/vnd.github+json" \
  167. "${GITHUB_API}" 2>/dev/null) || {
  168. # Network failure is non-fatal for update checks
  169. return 0
  170. }
  171. local latest_version
  172. latest_version=$(printf '%s' "${api_response}" | python3 -c "
  173. import json, sys
  174. try:
  175. data = json.load(sys.stdin)
  176. tag = data.get('tag_name', '')
  177. # Strip leading 'v' if present
  178. print(tag.lstrip('v'))
  179. except Exception:
  180. print('')
  181. " 2>/dev/null || echo "")
  182. if [[ -z "${latest_version}" ]]; then
  183. return 0
  184. fi
  185. # Write cache
  186. local now
  187. now=$(date +%s)
  188. python3 -c "
  189. import json, os
  190. path = '${UPDATES_FILE}'
  191. try:
  192. data = json.load(open(path))
  193. except Exception:
  194. data = {}
  195. data.setdefault('skills', {})
  196. data['skills']['${SKILL_NAME}'] = {
  197. 'last_check': ${now},
  198. 'latest': '${latest_version}',
  199. 'current': '${VERSION}'
  200. }
  201. with open(path, 'w') as f:
  202. json.dump(data, f, indent=2)
  203. " 2>/dev/null || true
  204. if [[ "${latest_version}" != "${VERSION}" ]]; then
  205. warn "Update available: ${VERSION} -> ${latest_version}"
  206. info "Run: curl -fsSL https://raw.githubusercontent.com/${REPO_OWNER}/${REPO_NAME}/main/install.sh | bash"
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 235 on GitHub
  207. else
  208. ok "You are on the latest version (${VERSION})"
  209. fi
  210. }
  211. # ---------------------------------------------------------------------------
  212. # Install logic
  213. # ---------------------------------------------------------------------------
  214. install_skill() {
  215. local mode="install"
  216. info "Claude Code Skill Installer"
  217. info "Skill: ${BOLD}${SKILL_NAME}${RESET} v${VERSION}"
  218. printf "\n"
  219. require_cmd git
  220. # ------------------------------------------------------------------
  221. # Detect upgrade vs fresh install
  222. # ------------------------------------------------------------------
  223. if [[ -d "${SKILL_DIR}" ]]; then
  224. mode="upgrade"
  225. local existing_version="unknown"
  226. if [[ -f "${SKILL_DIR}/.version" ]]; then
  227. existing_version=$(head -1 "${SKILL_DIR}/.version" 2>/dev/null || echo "unknown")
  228. fi
  229. info "Existing installation detected (${existing_version})"
  230. info "Mode: upgrade"
  231. # Back up SKILL.md if it exists
  232. if [[ -f "${SKILL_DIR}/SKILL.md" ]]; then
  233. cp "${SKILL_DIR}/SKILL.md" "${SKILL_DIR}/SKILL.md.bak"
  234. ok "Backed up SKILL.md -> SKILL.md.bak"
  235. fi
  236. else
  237. info "Mode: fresh install"
  238. fi
  239. # ------------------------------------------------------------------
  240. # Clone repo to temp directory
  241. # ------------------------------------------------------------------
  242. TMPDIR_SKILL=$(mktemp -d "${TMPDIR:-/tmp}/claude-skill-XXXXXX")
  243. info "Cloning ${REPO_OWNER}/${REPO_NAME}..."
  244. # Pin to this installer's own release tag so a fetched installer always
  245. # installs the matching tree; fall back to default branch if the tag is
  246. # missing (e.g. running from a working copy ahead of the release).
  247. git clone --depth 1 --quiet --branch "v${VERSION}" "${CLONE_URL}" "${TMPDIR_SKILL}/repo" 2>/dev/null \
  248. || git clone --depth 1 --quiet "${CLONE_URL}" "${TMPDIR_SKILL}/repo" 2>/dev/null \
  249. || die "Failed to clone repository. Check REPO_OWNER/REPO_NAME and network."
  250. # ------------------------------------------------------------------
  251. # Locate skill source within the repo
  252. # ------------------------------------------------------------------
  253. # Convention: skill files live at repo root OR under a directory named
  254. # after the skill. We check both.
  255. local src_dir="${TMPDIR_SKILL}/repo"
  256. if [[ -d "${TMPDIR_SKILL}/repo/${SKILL_NAME}" ]]; then
  257. src_dir="${TMPDIR_SKILL}/repo/${SKILL_NAME}"
  258. fi
  259. # Verify at minimum SKILL.md exists
  260. if [[ ! -f "${src_dir}/SKILL.md" ]]; then
  261. die "SKILL.md not found in repository (checked ${src_dir}). Cannot install."
  262. fi
  263. # ------------------------------------------------------------------
  264. # Copy skill files to SKILL_DIR
  265. # ------------------------------------------------------------------
  266. mkdir -p "${SKILL_DIR}"
  267. # Core file: SKILL.md (always required)
  268. cp "${src_dir}/SKILL.md" "${SKILL_DIR}/SKILL.md"
  269. ok "Installed SKILL.md"
  270. # Required: script.py shim + the prd_taskmaster package it imports
  271. if [[ -f "${src_dir}/script.py" ]]; then
  272. cp "${src_dir}/script.py" "${SKILL_DIR}/script.py"
  273. ok "Installed script.py"
  274. fi
  275. if [[ -d "${src_dir}/prd_taskmaster" ]]; then
  276. rm -rf "${SKILL_DIR}/prd_taskmaster"
  277. cp -r "${src_dir}/prd_taskmaster" "${SKILL_DIR}/prd_taskmaster"
  278. # drop bytecode caches so the copy is clean
  279. rm -rf "${SKILL_DIR}/prd_taskmaster/__pycache__"
  280. ok "Installed prd_taskmaster/ package"
  281. fi
  282. # Optional: phases/ directory (the 4-phase runbooks)
  283. if [[ -d "${src_dir}/phases" ]]; then
  284. rm -rf "${SKILL_DIR}/phases"
  285. cp -r "${src_dir}/phases" "${SKILL_DIR}/phases"
  286. ok "Installed phases/"
  287. fi
  288. # Optional: templates/ directory
  289. if [[ -d "${src_dir}/templates" ]]; then
  290. rm -rf "${SKILL_DIR}/templates"
  291. cp -r "${src_dir}/templates" "${SKILL_DIR}/templates"
  292. ok "Installed templates/"
  293. fi
  294. # Optional: reference/ directory
  295. if [[ -d "${src_dir}/reference" ]]; then
  296. rm -rf "${SKILL_DIR}/reference"
  297. cp -r "${src_dir}/reference" "${SKILL_DIR}/reference"
  298. ok "Installed reference/"
  299. fi
  300. # Optional: install.sh itself (so the skill is self-updating)
  301. if [[ -f "${src_dir}/install.sh" ]]; then
  302. cp "${src_dir}/install.sh" "${SKILL_DIR}/install.sh"
  303. chmod +x "${SKILL_DIR}/install.sh"
  304. fi
  305. # ------------------------------------------------------------------
  306. # Write .version file
  307. # ------------------------------------------------------------------
  308. local timestamp
  309. timestamp=$(date -u '+%Y-%m-%dT%H:%M:%SZ')
  310. cat > "${SKILL_DIR}/.version" <<VEOF
  311. ${VERSION}
  312. installed: ${timestamp}
  313. mode: ${mode}
  314. repo: ${REPO_OWNER}/${REPO_NAME}
  315. VEOF
  316. ok "Wrote .version (${VERSION}, ${timestamp})"
  317. # ------------------------------------------------------------------
  318. # Install the /atlas alias skill (thin delegator to this skill)
  319. # ------------------------------------------------------------------
  320. mkdir -p "${ALIAS_DIR}"
  321. cat > "${ALIAS_DIR}/SKILL.md" <<ALIASEOF
  322. ---
  323. name: ${ALIAS_NAME}
  324. description: >-
  325. The Atlas engine — turn any goal into a validated PRD and an executable,
  326. verified task graph. Alias for the prd-taskmaster skill. Use when the user
  327. invokes /atlas, says "I want to build", or asks for a PRD / task-driven build.
  328. allowed-tools:
  329. - Read
  330. - Write
  331. - Edit
  332. - Grep
  333. - Glob
  334. - Bash
  335. - Skill
  336. - AskUserQuestion
  337. - WebSearch
  338. - ToolSearch
  339. - mcp__atlas-engine
  340. - mcp__plugin_prd_go
  341. - mcp__plugin_prd-taskmaster_go
  342. - mcp__plugin_atlas-go_go
  343. ---
  344. # /atlas — the Atlas engine
  345. This is a thin alias. Immediately Read and follow the full engine skill:
  346. \`\`\`
  347. Read ${SKILL_DIR}/SKILL.md
  348. \`\`\`
  349. Then execute that skill's pipeline (Backend Resolution -> Preflight -> Discovery ->
  350. Generate -> Handoff) exactly as written, carrying over whatever goal or arguments the
  351. user provided. Do not skip the skill's Phase 0 (engine backend resolution via ToolSearch).
  352. ALIASEOF
  353. ok "Installed /atlas alias skill -> ${ALIAS_DIR}"
  354. # ------------------------------------------------------------------
  355. # Deprecation: superseded standalone prd-taskmaster-v2 skill dir
  356. # ------------------------------------------------------------------
  357. local legacy_dir="${HOME}/.claude/skills/prd-taskmaster-v2"
  358. if [[ -d "${legacy_dir}" ]]; then
  359. warn "Found legacy skill dir: ${legacy_dir}"
  360. warn "It is superseded by prd-taskmaster v${VERSION}. Remove it with:"
  361. printf " rm -rf %s\n" "${legacy_dir}"
  362. fi
  363. offer_taskmaster_backend
  364. # ------------------------------------------------------------------
  365. # Success
  366. # ------------------------------------------------------------------
  367. printf "\n"
  368. printf "${GREEN}${BOLD}Successfully %s ${SKILL_NAME} v${VERSION}${RESET}\n" \
  369. "$([ "${mode}" = "upgrade" ] && echo "upgraded" || echo "installed")"
  370. printf " Location: %s\n" "${SKILL_DIR}"
  371. if [[ "${mode}" = "upgrade" ]] && [[ -f "${SKILL_DIR}/SKILL.md.bak" ]]; then
  372. printf " Backup: %s\n" "${SKILL_DIR}/SKILL.md.bak"
  373. fi
  374. printf "\n"
  375. info "Open any project in Claude Code and type:"
  376. printf " ${CYAN}/atlas${RESET} (or ${CYAN}/%s${RESET}, or just say \"I want to build …\")\n" "${SKILL_NAME}"
  377. printf "\n"
  378. }
  379. # ---------------------------------------------------------------------------
  380. # Entrypoint
  381. # ---------------------------------------------------------------------------
  382. main() {
  383. local action="install"
  384. while [[ $# -gt 0 ]]; do
  385. case "$1" in
  386. --check-update|-u)
  387. action="check-update"
  388. ;;
  389. --version|-v)
  390. action="version"
  391. ;;
  392. --help|-h)
  393. action="help"
  394. ;;
  395. --with-taskmaster)
  396. set_taskmaster_install_mode "with"
  397. ;;
  398. --no-taskmaster)
  399. set_taskmaster_install_mode "without"
  400. ;;
  401. *)
  402. die "Unknown argument: $1 (try --help)"
  403. ;;
  404. esac
  405. shift
  406. done
  407. case "${action}" in
  408. check-update)
  409. check_update
  410. ;;
  411. version)
  412. echo "${SKILL_NAME} v${VERSION}"
  413. ;;
  414. help)
  415. printf "Usage: %s [--with-taskmaster | --no-taskmaster | --check-update | --version | --help]\n" "${0##*/}"
  416. printf "\n"
  417. printf " (no args) Install or upgrade the skill\n"
  418. printf " --with-taskmaster Install optional task-master-ai package\n"
  419. printf " --no-taskmaster Skip optional TaskMaster backend install\n"
  420. printf " --check-update Check GitHub for a newer release\n"
  421. printf " --version Print current version\n"
  422. printf " --help Show this help\n"
  423. ;;
  424. install)
  425. install_skill
  426. check_update
  427. ;;
  428. esac
  429. }
  430. main "$@"

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.