atlas-prd-taskmaster
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.
Badge for your README
Markdown
[](/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)
- {
- "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
- "name": "atlas-prd-taskmaster",
- "description": "Marketplace manifest for the prd plugin (the Atlas engine). Add with: /plugin marketplace add anombyte93/prd-taskmaster",
- "owner": {
- "name": "Atlas-X-AI"
- },
- "plugins": [
- {
- "name": "prd",
- "description": "Zero-config goal-to-tasks engine for Claude Code, plugin-native rebuild with CDD-verified execution",
- "source": "./",
- "category": "development"
- }
- ]
- }
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)
- # Turn any goal into shipped code.
- **prd-taskmaster** by [Atlas AI](https://atlas-ai.au) is an open-source engine for Claude Code
- that takes a one-line goal, interviews you like a senior PM, writes a **graded,
- placeholder-proof PRD**, compiles it into a **dependency-ordered task graph**, and executes every
- task with **verification evidence** — so "done" means proven, not claimed.
- Free and MIT, forever.
- > ⚠️ **Pre-alpha — under active development.** Atlas was recently consolidated into this engine
- > and the newer systems (fleet orchestration, backend abstraction, token economy) have **not been
- > fully tested in the wild yet**. Expect rough edges and breaking changes between releases, pin a
- > version if you need stability, and please [report what breaks](https://github.com/anombyte93/prd-taskmaster/issues).
- > No warranty beyond the MIT license. **Atlas Pro is not generally available** — it is a private
- > pilot (see below).
- Atlas has four structural moats:
- - **cross-vendor fleet** — Claude, Codex, and Gemini run as separate quota pools instead of one
- brittle model lane.
- - **Engine-enforced unfakable gates** — `validate-tasks`, evidence checks, and `SHIP_CHECK_OK`
- make completion a deterministic state, not a claim.
- - **persistent vendor-neutral `tasks.json`** — your PRD, task graph, and execution state stay as
- plain repo files that survive vendor swaps.
- - **token-economy cost ledger** — every orchestrated model call records routing, exit, latency,
- and escalation so cheap models do cheap work and expensive models justify themselves.
- **Atlas speaks TaskMaster natively — but doesn't need it.** Existing TaskMaster projects get a
- migration funnel: install `task-master-ai` only when you want the TaskMaster backend, while the
- native backend keeps the same validated task graph available without that prerequisite.
- ```
- Grade: GOOD ▰▰▰▰▰▰▰▰▱▱ 49/57 (86%) · 0 placeholders · 14 tasks parsed
- ```
- [](#project-status)
- [](LICENSE)
- [](https://github.com/anombyte93/prd-taskmaster/stargazers)
- [](https://atlas-ai.au)
- [](#whats-open-whats-not)
- ---
- ## How it works
- ```
- goal → discovery interview → graded PRD → dependency-ordered task graph → verified execution
- ```
- 1. **Preflight** — detects your environment (native backend, optional TaskMaster backend, model CLIs, research) and configures it. Zero setup questions.
- 2. **Discovery** — an adaptive, one-question-at-a-time interview captures your real constraints.
- 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.
- 4. **Handoff** — detects what you have installed and recommends one execution mode.
- 5. **Execute** — a CDD-gated loop implements each task and proves it with evidence, ending in a deterministic `SHIP_CHECK_OK` token.
- ---
- ## Quickstart
- 90 seconds to your first run.
- ### Path 1 — one-liner (recommended)
- ```bash
- 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
- # installs the skill + prd_taskmaster package
- # TaskMaster install is optional — unlocks the TaskMaster backend
- ```
- ### Path 2 — Claude Code plugin
- ```bash
- # 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 "verified" means
- Most AI coding tools tell you a task is done. This one makes "done" provable:
- - **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.
- - **A real task graph.** Requirements become backend-neutral `tasks.json` tasks with dependencies, complexity scores, and full subtask coverage — not a flat checklist.
- - **Evidence-gated execution.** Each task is implemented and must produce execution evidence before it counts as done.
- - **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.)
- ```
- ┌─ atlas ── PHASE 3/4: GENERATE ─────────────────────────────┐
- │ Grade: GOOD ▰▰▰▰▰▰▰▰▱▱ 49/57 (86%) │
- │ ✓ 11 checks passed structure · testability · metrics │
- │ ⚠ 2 warnings (quoted + located, not just counted) │
- │ ✓ 0 placeholders (TBD/TODO/{{...}} scan clean) │
- │ Tasks: 14 parsed · 52 subtasks · dependencies mapped │
- └────────────────────────────────────────────────────────────┘
- ```
- ---
- ## Project status
- **Pre-alpha.** The deterministic core — graded PRD validation, the task graph, the ship-check
- gate, the CLI — is covered by ~300 tests and is the most stable surface. The newer systems
- around it (cross-vendor fleet, backend abstraction, the token-economy ledger, the bundled Pro
- MCPs) are **recently built and not yet battle-tested**; their numbers (e.g. cost savings) are
- verified-rate *estimates*, not measured guarantees (see
- [`docs/product/MODEL-ECONOMY.md`](docs/product/MODEL-ECONOMY.md)). Expect breaking changes
- between releases; pin a version for stability. Bug reports and use-case notes are the fastest way
- to move it toward stable — [open an issue](https://github.com/anombyte93/prd-taskmaster/issues).
- ## Built for the token-shortage era
- Every job runs on the cheapest model that can do it — and escalates only when a validator says
- it failed. One setting controls how aggressive that is:
- ```json
- // .atlas-ai/fleet.json
- { "token_economy": "conservative" } // or "balanced" (default) / "performance"
- ```
- Task decomposition and research run through the selected backend. Native mode works without a
- TaskMaster install; installing `task-master-ai >= 0.43.0` unlocks TaskMaster's model-agnostic AI
- (any API you configure — Anthropic, OpenAI, Perplexity, Gemini, openai-compatible…) and isolated
- workdir expansion when that backend is selected. Complexity 2 scaffolding gets a haiku-class
- model; the hardest long-running work gets the frontier model; nothing defaults to expensive.
- Local telemetry (`economy-report`) shows your real success-rate and latency per model so the
- routing gets smarter on YOUR workload — priors and sources in
- [`docs/product/MODEL-ECONOMY.md`](docs/product/MODEL-ECONOMY.md).
- ## Free vs Atlas Pro
- > **Atlas Pro is in private pilot — not generally available and not yet for sale.** Pricing is
- > not set. During the pilot, access is granted at our discretion to testers with a strong use
- > case (often free). The table shows what Pro *will* add; the Pro-only rows are **experimental and
- > not fully tested**. Want in? **[Request pilot access →](https://github.com/anombyte93/prd-taskmaster/discussions)**
- > (an on-site signup at `atlas-ai.au/pilot` to be notified at launch is coming).
- | | Free (MIT) | Atlas Pro — private pilot |
- |---|:---:|:---:|
- | Discovery interview (adaptive, one question at a time) | ✓ | ✓ |
- | Graded PRD validation + placeholder scan | ✓ | ✓ |
- | Dependency-ordered task graph (`tasks.json`) | ✓ | ✓ |
- | Verified solo execution — evidence required per task | ✓ | ✓ |
- | Model-agnostic: Claude / Codex / Gemini | ✓ | ✓ |
- | Parallel research fan-out | ✓ | ✓ |
- | **Token economy** — start cheap, escalate only on failure (conservative/balanced/performance) | ✓ | ✓ |
- | Optional **TaskMaster backend** expansion — any configured API, isolated workdirs | ✓ | ✓ |
- | Local cost telemetry + `economy-report` | ✓ | ✓ |
- | Adaptive routing auto-tuning from telemetry | — | ✓ (roadmap) |
- | **Atlas Fleet** — parallel waves of isolated workers, checker-gated merges, one final PR | — | ✓ |
- | Browser-verification MCP (UI proof, not just logs) | — | ✓ |
- | Secrets-vault MCP (keys never in your repo or prompts) | — | ✓ |
- | License & priority support | community | ✓ |
- The engine is the whole engine — the free tier is **not a demo**. Pro adds the fleet orchestrator
- and bundled MCPs (both pilot-stage, not fully tested). [Request pilot access →](https://github.com/anombyte93/prd-taskmaster/discussions)
- ---
- ## Atlas Fleet (Atlas Pro)
- When a build is big enough to want overnight parallelism, **Atlas Fleet** lifts the same engine
- from one session to many. It splits your task graph into dependency **waves** of file-disjoint
- chunks, spawns model-agnostic workers (Claude / Codex / Gemini) in isolated **git worktrees**,
- collects results through a durable inbox rather than trusting an agent's word, and merges waves
- sequentially into an integration branch behind a checker gate — never touching `main` until one
- final green PR.
- It runs entirely on your machine. Your specs and tasks are plain files in your repo, nothing is
- held hostage. **Fleet is pilot-stage and not yet hardened** — treat it as a preview.
- [Request pilot access →](https://github.com/anombyte93/prd-taskmaster/discussions)
- ---
- ## What's open, what's not
- **Open (MIT, free forever):** discovery, PRD validation, the task graph, and solo verified
- execution — the entire engine in this repo. Read every line.
- **Closed (Atlas Pro):** the `atlas-launcher` fleet orchestrator and the two bundled MCPs
- (browser verification, secrets vault). The engine repo will never require a license key.
- ---
- ## FAQ
- **Will the free engine stay free?** Yes — MIT, and this repo will never require a key.
- **What happens if I cancel Pro?** Fleet locks again; everything free keeps working. Your specs
- and tasks are plain files in your repo.
- **Do I need a paid API key?** No. The engine uses the model CLIs you already have (Claude Code,
- Codex, Gemini); an optional local research proxy can be plugged in (bring your own — not bundled).
- **Do I need TaskMaster?** No. Atlas speaks TaskMaster natively but doesn't require it —
- Native Mode produces the same validated task graph (validate-tasks + enrich-tasks). Installing
- `task-master-ai >= 0.43.0` unlocks the TaskMaster backend: Mode B auto-execute and
- native-parallel expansion through TaskMaster's 13-provider model layer.
- **Which platforms?** Linux, macOS, and WSL. (Native Windows is not supported — the atomic state
- machine uses POSIX file locking.)
- ---
- ## Contributing & License
- Issues and PRs welcome — see [CONTRIBUTING.md](CONTRIBUTING.md) and
- [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md). Product and UX specifications live in
- [`docs/product/`](docs/product/).
- The engine is **MIT licensed and will always be** — see [LICENSE](LICENSE). Upgrading from v3?
- See [CHANGELOG.md](CHANGELOG.md). v3 remains available via `git checkout v3.0.0`.
install.sh · Bundled script · 490 lines · 3 findings marked
- #!/usr/bin/env bash
- # ============================================================================
- # Universal Claude Code Skill Installer
- # ============================================================================
- # Usage:
- # 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
- # bash install.sh # fresh install or upgrade
- # bash install.sh --with-taskmaster # also install the optional TaskMaster backend
- # bash install.sh --no-taskmaster # skip the optional TaskMaster backend offer
- # bash install.sh --check-update # check for newer version only
- #
- # Customize the variables below for your skill repository.
- # ============================================================================
- set -euo pipefail
- # ---------------------------------------------------------------------------
- # Skill Configuration (customize these per-repo)
- # ---------------------------------------------------------------------------
- REPO_OWNER="anombyte93"
- REPO_NAME="prd-taskmaster"
- SKILL_NAME="prd-taskmaster"
- VERSION="5.3.1"
- SKILL_DIR="${SKILL_DIR:-${HOME}/.claude/skills/${SKILL_NAME}}"
- ALIAS_NAME="atlas"
- ALIAS_DIR="${HOME}/.claude/skills/${ALIAS_NAME}"
- TASKMASTER_INSTALL_MODE="ask"
- # ---------------------------------------------------------------------------
- # Internal constants
- # ---------------------------------------------------------------------------
- UPDATES_DIR="${HOME}/.config/claude-skills"
- UPDATES_FILE="${UPDATES_DIR}/updates.json"
- UPDATE_INTERVAL_SECONDS=86400 # 24 hours
- GITHUB_API="https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/releases/latest"
- CLONE_URL="https://github.com/${REPO_OWNER}/${REPO_NAME}.git"
- # ---------------------------------------------------------------------------
- # Colors (disabled when piped or in CI)
- # ---------------------------------------------------------------------------
- if [[ -t 1 ]] && [[ -z "${CI:-}" ]] && [[ -z "${NO_COLOR:-}" ]]; then
- RED='\033[0;31m'
- GREEN='\033[0;32m'
- YELLOW='\033[0;33m'
- CYAN='\033[0;36m'
- BOLD='\033[1m'
- RESET='\033[0m'
- else
- RED='' GREEN='' YELLOW='' CYAN='' BOLD='' RESET=''
- fi
- # ---------------------------------------------------------------------------
- # Helpers
- # ---------------------------------------------------------------------------
- info() { printf "${CYAN}[info]${RESET} %s\n" "$*"; }
- ok() { printf "${GREEN}[ok]${RESET} %s\n" "$*"; }
- warn() { printf "${YELLOW}[warn]${RESET} %s\n" "$*"; }
- err() { printf "${RED}[error]${RESET} %s\n" "$*" >&2; }
- die() { err "$@"; exit 1; }
- cleanup() {
- if [[ -n "${TMPDIR_SKILL:-}" ]] && [[ -d "${TMPDIR_SKILL}" ]]; then
- rm -rf "${TMPDIR_SKILL}"
- fi
- }
- trap cleanup EXIT
- require_cmd() {
- command -v "$1" >/dev/null 2>&1 || die "Required command not found: $1"
- }
- set_taskmaster_install_mode() {
- local requested="$1"
- if [[ "${TASKMASTER_INSTALL_MODE}" != "ask" ]] && [[ "${TASKMASTER_INSTALL_MODE}" != "${requested}" ]]; then
- die "Conflicting TaskMaster backend flags: choose --with-taskmaster or --no-taskmaster"
- fi
- TASKMASTER_INSTALL_MODE="${requested}"
- }
- install_taskmaster_backend() {
- info "Installing optional task-master-ai package (unlocks the TaskMaster backend)"
- if command -v task-master-ai >/dev/null 2>&1; then
- ok "TaskMaster backend already available"
- return 0
- fi
- if ! command -v npm >/dev/null 2>&1; then
- warn "npm not found; skipping optional TaskMaster backend install"
- warn "Atlas native backend remains available"
- return 0
- fi
- if npm install -g task-master-ai; then
- ok "Installed optional TaskMaster backend"
- else
- warn "Optional TaskMaster backend install failed"
- warn "Atlas native backend remains available"
- fi
- }
- offer_taskmaster_backend() {
- case "${TASKMASTER_INSTALL_MODE}" in
- with)
- install_taskmaster_backend
- ;;
- without)
- info "Skipping optional TaskMaster backend install (--no-taskmaster)"
- ;;
- ask)
- if [[ ! -t 0 ]]; then
- info "Non-interactive shell; skipping optional TaskMaster backend install"
- info "Use --with-taskmaster to install task-master-ai when you want the TaskMaster backend"
- return 0
- fi
- local answer
- printf "Install optional task-master-ai package (unlocks the TaskMaster backend)? [Y/n] "
- read -r answer || answer=""
- case "${answer:-Y}" in
- Y|y|YES|Yes|yes)
- install_taskmaster_backend
- ;;
- N|n|NO|No|no)
- info "Skipping optional TaskMaster backend install"
- ;;
- *)
- warn "Unrecognized answer; skipping optional TaskMaster backend install"
- ;;
- esac
- ;;
- esac
- }
- # ---------------------------------------------------------------------------
- # Update check (callable standalone)
- # ---------------------------------------------------------------------------
- check_update() {
- # Respect CI / explicit opt-out
- if [[ -n "${CI:-}" ]] || [[ -n "${NO_UPDATE_CHECK:-}" ]]; then
- return 0
- fi
- require_cmd curl
- require_cmd date
- mkdir -p "${UPDATES_DIR}"
- # Throttle: only check once per UPDATE_INTERVAL_SECONDS
- if [[ -f "${UPDATES_FILE}" ]]; then
- local last_check
- last_check=$(python3 -c "
- import json, sys
- try:
- d = json.load(open('${UPDATES_FILE}'))
- print(d.get('skills', {}).get('${SKILL_NAME}', {}).get('last_check', 0))
- except Exception:
- print(0)
- " 2>/dev/null || echo 0)
- local now
- now=$(date +%s)
- local elapsed=$(( now - last_check ))
- if [[ ${elapsed} -lt ${UPDATE_INTERVAL_SECONDS} ]]; then
- # Within cooldown -- read cached result
- local cached_latest
- cached_latest=$(python3 -c "
- import json
- try:
- d = json.load(open('${UPDATES_FILE}'))
- print(d.get('skills', {}).get('${SKILL_NAME}', {}).get('latest', ''))
- except Exception:
- print('')
- " 2>/dev/null || echo "")
- if [[ -n "${cached_latest}" ]] && [[ "${cached_latest}" != "${VERSION}" ]]; then
- warn "Update available: ${VERSION} -> ${cached_latest}"
- 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
- fi
- return 0
- fi
- fi
- # Fetch latest release from GitHub API
- local api_response
- api_response=$(curl -fsSL --max-time 5 \
- -H "Accept: application/vnd.github+json" \
- "${GITHUB_API}" 2>/dev/null) || {
- # Network failure is non-fatal for update checks
- return 0
- }
- local latest_version
- latest_version=$(printf '%s' "${api_response}" | python3 -c "
- import json, sys
- try:
- data = json.load(sys.stdin)
- tag = data.get('tag_name', '')
- # Strip leading 'v' if present
- print(tag.lstrip('v'))
- except Exception:
- print('')
- " 2>/dev/null || echo "")
- if [[ -z "${latest_version}" ]]; then
- return 0
- fi
- # Write cache
- local now
- now=$(date +%s)
- python3 -c "
- import json, os
- path = '${UPDATES_FILE}'
- try:
- data = json.load(open(path))
- except Exception:
- data = {}
- data.setdefault('skills', {})
- data['skills']['${SKILL_NAME}'] = {
- 'last_check': ${now},
- 'latest': '${latest_version}',
- 'current': '${VERSION}'
- }
- with open(path, 'w') as f:
- json.dump(data, f, indent=2)
- " 2>/dev/null || true
- if [[ "${latest_version}" != "${VERSION}" ]]; then
- warn "Update available: ${VERSION} -> ${latest_version}"
- 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
- else
- ok "You are on the latest version (${VERSION})"
- fi
- }
- # ---------------------------------------------------------------------------
- # Install logic
- # ---------------------------------------------------------------------------
- install_skill() {
- local mode="install"
- info "Claude Code Skill Installer"
- info "Skill: ${BOLD}${SKILL_NAME}${RESET} v${VERSION}"
- printf "\n"
- require_cmd git
- # ------------------------------------------------------------------
- # Detect upgrade vs fresh install
- # ------------------------------------------------------------------
- if [[ -d "${SKILL_DIR}" ]]; then
- mode="upgrade"
- local existing_version="unknown"
- if [[ -f "${SKILL_DIR}/.version" ]]; then
- existing_version=$(head -1 "${SKILL_DIR}/.version" 2>/dev/null || echo "unknown")
- fi
- info "Existing installation detected (${existing_version})"
- info "Mode: upgrade"
- # Back up SKILL.md if it exists
- if [[ -f "${SKILL_DIR}/SKILL.md" ]]; then
- cp "${SKILL_DIR}/SKILL.md" "${SKILL_DIR}/SKILL.md.bak"
- ok "Backed up SKILL.md -> SKILL.md.bak"
- fi
- else
- info "Mode: fresh install"
- fi
- # ------------------------------------------------------------------
- # Clone repo to temp directory
- # ------------------------------------------------------------------
- TMPDIR_SKILL=$(mktemp -d "${TMPDIR:-/tmp}/claude-skill-XXXXXX")
- info "Cloning ${REPO_OWNER}/${REPO_NAME}..."
- # Pin to this installer's own release tag so a fetched installer always
- # installs the matching tree; fall back to default branch if the tag is
- # missing (e.g. running from a working copy ahead of the release).
- git clone --depth 1 --quiet --branch "v${VERSION}" "${CLONE_URL}" "${TMPDIR_SKILL}/repo" 2>/dev/null \
- || git clone --depth 1 --quiet "${CLONE_URL}" "${TMPDIR_SKILL}/repo" 2>/dev/null \
- || die "Failed to clone repository. Check REPO_OWNER/REPO_NAME and network."
- # ------------------------------------------------------------------
- # Locate skill source within the repo
- # ------------------------------------------------------------------
- # Convention: skill files live at repo root OR under a directory named
- # after the skill. We check both.
- local src_dir="${TMPDIR_SKILL}/repo"
- if [[ -d "${TMPDIR_SKILL}/repo/${SKILL_NAME}" ]]; then
- src_dir="${TMPDIR_SKILL}/repo/${SKILL_NAME}"
- fi
- # Verify at minimum SKILL.md exists
- if [[ ! -f "${src_dir}/SKILL.md" ]]; then
- die "SKILL.md not found in repository (checked ${src_dir}). Cannot install."
- fi
- # ------------------------------------------------------------------
- # Copy skill files to SKILL_DIR
- # ------------------------------------------------------------------
- mkdir -p "${SKILL_DIR}"
- # Core file: SKILL.md (always required)
- cp "${src_dir}/SKILL.md" "${SKILL_DIR}/SKILL.md"
- ok "Installed SKILL.md"
- # Required: script.py shim + the prd_taskmaster package it imports
- if [[ -f "${src_dir}/script.py" ]]; then
- cp "${src_dir}/script.py" "${SKILL_DIR}/script.py"
- ok "Installed script.py"
- fi
- if [[ -d "${src_dir}/prd_taskmaster" ]]; then
- rm -rf "${SKILL_DIR}/prd_taskmaster"
- cp -r "${src_dir}/prd_taskmaster" "${SKILL_DIR}/prd_taskmaster"
- # drop bytecode caches so the copy is clean
- rm -rf "${SKILL_DIR}/prd_taskmaster/__pycache__"
- ok "Installed prd_taskmaster/ package"
- fi
- # Optional: phases/ directory (the 4-phase runbooks)
- if [[ -d "${src_dir}/phases" ]]; then
- rm -rf "${SKILL_DIR}/phases"
- cp -r "${src_dir}/phases" "${SKILL_DIR}/phases"
- ok "Installed phases/"
- fi
- # Optional: templates/ directory
- if [[ -d "${src_dir}/templates" ]]; then
- rm -rf "${SKILL_DIR}/templates"
- cp -r "${src_dir}/templates" "${SKILL_DIR}/templates"
- ok "Installed templates/"
- fi
- # Optional: reference/ directory
- if [[ -d "${src_dir}/reference" ]]; then
- rm -rf "${SKILL_DIR}/reference"
- cp -r "${src_dir}/reference" "${SKILL_DIR}/reference"
- ok "Installed reference/"
- fi
- # Optional: install.sh itself (so the skill is self-updating)
- if [[ -f "${src_dir}/install.sh" ]]; then
- cp "${src_dir}/install.sh" "${SKILL_DIR}/install.sh"
- chmod +x "${SKILL_DIR}/install.sh"
- fi
- # ------------------------------------------------------------------
- # Write .version file
- # ------------------------------------------------------------------
- local timestamp
- timestamp=$(date -u '+%Y-%m-%dT%H:%M:%SZ')
- cat > "${SKILL_DIR}/.version" <<VEOF
- ${VERSION}
- installed: ${timestamp}
- mode: ${mode}
- repo: ${REPO_OWNER}/${REPO_NAME}
- VEOF
- ok "Wrote .version (${VERSION}, ${timestamp})"
- # ------------------------------------------------------------------
- # Install the /atlas alias skill (thin delegator to this skill)
- # ------------------------------------------------------------------
- mkdir -p "${ALIAS_DIR}"
- cat > "${ALIAS_DIR}/SKILL.md" <<ALIASEOF
- ---
- name: ${ALIAS_NAME}
- description: >-
- The Atlas engine — turn any goal into a validated PRD and an executable,
- verified task graph. Alias for the prd-taskmaster skill. Use when the user
- invokes /atlas, says "I want to build", or asks for a PRD / task-driven build.
- allowed-tools:
- - Read
- - Write
- - Edit
- - Grep
- - Glob
- - Bash
- - Skill
- - AskUserQuestion
- - WebSearch
- - ToolSearch
- - mcp__atlas-engine
- - mcp__plugin_prd_go
- - mcp__plugin_prd-taskmaster_go
- - mcp__plugin_atlas-go_go
- ---
- # /atlas — the Atlas engine
- This is a thin alias. Immediately Read and follow the full engine skill:
- \`\`\`
- Read ${SKILL_DIR}/SKILL.md
- \`\`\`
- Then execute that skill's pipeline (Backend Resolution -> Preflight -> Discovery ->
- Generate -> Handoff) exactly as written, carrying over whatever goal or arguments the
- user provided. Do not skip the skill's Phase 0 (engine backend resolution via ToolSearch).
- ALIASEOF
- ok "Installed /atlas alias skill -> ${ALIAS_DIR}"
- # ------------------------------------------------------------------
- # Deprecation: superseded standalone prd-taskmaster-v2 skill dir
- # ------------------------------------------------------------------
- local legacy_dir="${HOME}/.claude/skills/prd-taskmaster-v2"
- if [[ -d "${legacy_dir}" ]]; then
- warn "Found legacy skill dir: ${legacy_dir}"
- warn "It is superseded by prd-taskmaster v${VERSION}. Remove it with:"
- printf " rm -rf %s\n" "${legacy_dir}"
- fi
- offer_taskmaster_backend
- # ------------------------------------------------------------------
- # Success
- # ------------------------------------------------------------------
- printf "\n"
- printf "${GREEN}${BOLD}Successfully %s ${SKILL_NAME} v${VERSION}${RESET}\n" \
- "$([ "${mode}" = "upgrade" ] && echo "upgraded" || echo "installed")"
- printf " Location: %s\n" "${SKILL_DIR}"
- if [[ "${mode}" = "upgrade" ]] && [[ -f "${SKILL_DIR}/SKILL.md.bak" ]]; then
- printf " Backup: %s\n" "${SKILL_DIR}/SKILL.md.bak"
- fi
- printf "\n"
- info "Open any project in Claude Code and type:"
- printf " ${CYAN}/atlas${RESET} (or ${CYAN}/%s${RESET}, or just say \"I want to build …\")\n" "${SKILL_NAME}"
- printf "\n"
- }
- # ---------------------------------------------------------------------------
- # Entrypoint
- # ---------------------------------------------------------------------------
- main() {
- local action="install"
- while [[ $# -gt 0 ]]; do
- case "$1" in
- --check-update|-u)
- action="check-update"
- ;;
- --version|-v)
- action="version"
- ;;
- --help|-h)
- action="help"
- ;;
- --with-taskmaster)
- set_taskmaster_install_mode "with"
- ;;
- --no-taskmaster)
- set_taskmaster_install_mode "without"
- ;;
- *)
- die "Unknown argument: $1 (try --help)"
- ;;
- esac
- shift
- done
- case "${action}" in
- check-update)
- check_update
- ;;
- version)
- echo "${SKILL_NAME} v${VERSION}"
- ;;
- help)
- printf "Usage: %s [--with-taskmaster | --no-taskmaster | --check-update | --version | --help]\n" "${0##*/}"
- printf "\n"
- printf " (no args) Install or upgrade the skill\n"
- printf " --with-taskmaster Install optional task-master-ai package\n"
- printf " --no-taskmaster Skip optional TaskMaster backend install\n"
- printf " --check-update Check GitHub for a newer release\n"
- printf " --version Print current version\n"
- printf " --help Show this help\n"
- ;;
- install)
- install_skill
- check_update
- ;;
- esac
- }
- main "$@"
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.