Skip to content
Back to search

pm-kit

AI-augmented PM workspace for Coding Agents — daily standups, decisions, blockers, docs, and sprint reviews as markdown skills

Safety scan

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

Checked today

Check it deeper on your machine

Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/kv0906/pm-kit with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/kv0906/pm-kit'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/kv0906--pm-kit/badge.svg)](/listings/kv0906--pm-kit)

HTML

<a href="/listings/kv0906--pm-kit"><img src="/api/listings/kv0906--pm-kit/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

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.

Option A: CLI Install (Recommended)

# 1. Install the CLI
curl -fsSL https://raw.githubusercontent.com/kv0906/pm-kit/main/cli/install.sh | bash

# 2. Create your vault
pm-kit init ~/Documents/my-vault
cd ~/Documents/my-vault

# 3. Open the folder in Obsidian, then run Claude Code
claude
/onboard

Option B: GitHub Template

# 1. Use this template on GitHub (or clone)
git clone <your-repo-url>
cd pm-kit

# 2. Open the folder in Obsidian

# 3. Run Claude Code
claude
/onboard

`/onboard` sets up your project, learns your preferences, and loads context. Full walkthrough: **[START_HERE.md](START_HERE.md)**

Amp Orbs

Fresh Amp orbs run `.agents/setup` to prepare shell tools and locked document-export dependencies (Python, Node, LibreOffice, Pandoc, PDF tools, and OCR). Amp can reuse the prepared snapshot; warm setup checks existing packages instead of reinstalling them. `.agents` is a symlink to `.claude`, where the lifecycle scripts are tracked.

The setup does not run the interactive vault wizard, edit your notes or configuration, or authenticate integrations. QMD and account-specific integrations remain optional. There are no persistent services to start; `.agents/resume` performs no installs. New login shells inside the repository automatically use the document-tools Python environment and Node module path.

To verify setup manually from the repository root:

./.agents/setup
./.agents/resume
bash -lc 'python -c "import openpyxl, reportlab"; node -e "require(\"docx\"); require(\"pptxgenjs\")"'

Dependency manifests and locks live in `.claude/orb/`. To update them, edit `requirements.in` or `package.json`, regenerate the corresponding lock, and commit it:

uv pip compile .claude/orb/requirements.in -o .claude/orb/requirements.txt --python-version 3.11
npm install --prefix .claude/orb --package-lock-only --ignore-scripts

Orb setup must reach the project's default branch before future orbs use it.

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.

README.md · README · 243 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. ![PM-Kit — Your product thinking workspace. Evidence → Judgment → Outcomes.](./pm-kit-banner.png)
  2. # PM-Kit
  3. Turn your AI coding tool into a PM workspace, knowledge hub, and execution engine.
  4. ## Disclaimer
  5. This is not gospel. This is not the holy grail.
  6. PM-Kit is one system that works. It is a guideline and mindset shift, not a rigid rulebook.
  7. The principles in `_core/MANIFESTO.md` may resonate with you, or they may not. That is fine.
  8. Take what works. Ignore what does not. Make it yours.
  9. You will get better results through repetition. The framework should adapt to your workflow, not the other way around.
  10. ## Quick Start
  11. ### Option A: CLI Install (Recommended)
  12. ```bash
  13. # 1. Install the CLI
  14. curl -fsSL https://raw.githubusercontent.com/kv0906/pm-kit/main/cli/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 24 on GitHub
  15. # 2. Create your vault
  16. pm-kit init ~/Documents/my-vault
  17. cd ~/Documents/my-vault
  18. # 3. Open the folder in Obsidian, then run Claude Code
  19. claude
  20. /onboard
  21. ```
  22. ### Option B: GitHub Template
  23. ```bash
  24. # 1. Use this template on GitHub (or clone)
  25. git clone <your-repo-url>
  26. cd pm-kit
  27. # 2. Open the folder in Obsidian
  28. # 3. Run Claude Code
  29. claude
  30. /onboard
  31. ```
  32. `/onboard` sets up your project, learns your preferences, and loads context. Full walkthrough: **[START_HERE.md](START_HERE.md)**
  33. ### Amp Orbs
  34. Fresh Amp orbs run `.agents/setup` to prepare shell tools and locked document-export
  35. dependencies (Python, Node, LibreOffice, Pandoc, PDF tools, and OCR). Amp can reuse
  36. the prepared snapshot; warm setup checks existing packages instead of reinstalling them.
  37. `.agents` is a symlink to `.claude`, where the lifecycle scripts are tracked.
  38. The setup does not run the interactive vault wizard, edit your notes or configuration,
  39. or authenticate integrations. QMD and account-specific integrations remain optional.
  40. There are no persistent services to start; `.agents/resume` performs no installs.
  41. New login shells inside the repository automatically use the document-tools Python
  42. environment and Node module path.
  43. To verify setup manually from the repository root:
  44. ```bash
  45. ./.agents/setup
  46. ./.agents/resume
  47. bash -lc 'python -c "import openpyxl, reportlab"; node -e "require(\"docx\"); require(\"pptxgenjs\")"'
  48. ```
  49. Dependency manifests and locks live in `.claude/orb/`. To update them, edit
  50. `requirements.in` or `package.json`, regenerate the corresponding lock, and commit it:
  51. ```bash
  52. uv pip compile .claude/orb/requirements.in -o .claude/orb/requirements.txt --python-version 3.11
  53. npm install --prefix .claude/orb --package-lock-only --ignore-scripts
  54. ```
  55. Orb setup must reach the project's default branch before future orbs use it.
  56. ## Daily Routine
  57. ```
  58. /today # Guided workflow: standup → sync → review → focus → wrap-up
  59. /today wrap # Jump to end-of-day summary
  60. ```
  61. Or for quick atomic updates:
  62. ```
  63. /daily my-project: shipped X, wip Y, blocked on Z
  64. /push
  65. ```
  66. ## Weekly Routine
  67. ```
  68. /weekly
  69. /push
  70. ```
  71. ## Updating
  72. ```bash
  73. # CLI users
  74. pm-kit update # Update framework files from latest release
  75. pm-kit self-update # Update the CLI itself
  76. # Template users
  77. ./scripts/update.sh # Update framework files from latest release
  78. ```
  79. Or from within Claude: `/update`
  80. Updates only touch framework files (skills, templates, scripts, docs). Your notes, config, and content are never modified. Backups are saved to `_archive/_updates/`.
  81. ## All Commands
  82. | Command | Purpose |
  83. |---------|---------|
  84. | `/today` | Guided daily workflow orchestrator |
  85. | `/daily` | Multi-project standup logging |
  86. | `/progress` | Cross-project status synthesis |
  87. | `/preview` | Render docs and reports as styled HTML |
  88. | `/report` | Executive brief in plain language (CEO/PO view) |
  89. | `/block` | Structured blocker capture |
  90. | `/decide` | Decision records with alternatives |
  91. | `/doc` | Evidence-backed PRDs, user stories, and validation |
  92. | `/explain` | Explanations at the depth and language you need |
  93. | `/show-me` | Focused diagrams and visual explanations |
  94. | `/prioritize` | Direct triage, MoSCoW, RICE, or Kano when useful |
  95. | `/discover` | Root cause, I-P-O, JTBD, and research guidance |
  96. | `/journey` | User journey maps with evidence and friction |
  97. | `/meet` | Meeting extraction into actions/decisions |
  98. | `/inbox` | Fast capture for later processing |
  99. | `/ask` | Vault Q&A (QMD-powered when available) |
  100. | `/health` | Link + vault integrity checks |
  101. | `/weekly` | Review delivery, learning, outcomes, and next priorities |
  102. | `/push` | Commit and sync |
  103. | `/onboard` | Interactive setup + context loading |
  104. | `/update` | Check for and apply framework updates |
  105. | `/help` | Command reference and workflow cheat sheet |
  106. ## Product Thinking
  107. Use only the structure a decision needs. A small reversible request can receive direct
  108. triage; competing investments may need a comparison. MoSCoW defines release scope,
  109. RICE compares credible estimates, and Kano examines customer preferences with research.
  110. The kit chooses a method by the decision and missing evidence, then explains a non-obvious choice briefly.
  111. Opportunity maps, product-risk checks, and outcome measures live inside the existing workflows;
  112. you do not need to learn more commands or complete every framework for each request.
  113. ```text
  114. /discover project-a: why do users abandon checkout?
  115. /journey project-a: a returning customer completes checkout
  116. /prioritize project-a: compare the checkout requests for the next release
  117. /doc project-a checkout-flow
  118. ```
  119. `_core/judgment.md` defines product reasoning and approval boundaries.
  120. `_core/knowledge.md` separates evidence, assumptions, interpretations, and reviewed lessons.
  121. Keep personal judgment and writing examples in `_core/identity.md` or linked `docs/` notes;
  122. keep product context under `docs/{project}/`. Framework updates preserve those user files
  123. but replace the shared core guides. Unknown evidence stays unknown; shipped work does
  124. not automatically count as a measured outcome.
  125. ## Smarter /ask with QMD (Optional)
  126. Install [QMD](https://github.com/tobi/qmd) for hybrid search (BM25 + vector + rerank) that dramatically improves `/ask` accuracy. **Requires [bun](https://bun.sh) and technical comfort with CLI tools.** Without QMD, `/ask` still works using vault grep.
  127. ```bash
  128. # 1. Install bun (if not installed)
  129. curl -fsSL https://bun.sh/install | bash
  130. # 2. Install QMD and set up your vault
  131. bun install -g github:tobi/qmd
  132. qmd collection add . --name pm-kit
  133. # 3. Build the search index
  134. qmd embed
  135. ```
  136. After setup, `/ask` automatically uses QMD when available. No command changes needed.
  137. Having trouble? See [handbook/QMD_INTEGRATION.md](handbook/QMD_INTEGRATION.md) or [open an issue](https://github.com/kv0906/pm-kit/issues).
  138. ## Who Uses PM-Kit
  139. | Role | How They Use It |
  140. |------|------------------|
  141. | Product Managers / Product Owners | Run dailies, write PRDs, track blockers, align cross-functional work |
  142. | Engineering Leads | Capture decisions, drive sprint clarity, maintain technical context |
  143. | Engineers (Junior -> Senior) | Document context, ship specs, keep decisions traceable |
  144. | Founders / Solo Builders | Turn scattered thoughts into an execution system |
  145. | Analysts / Operators | Log research, synthesize findings, build durable knowledge |
  146. ## Works With
  147. | Tool | Status | How |
  148. |------|--------|-----|
  149. | Claude Code | Native | Reads `CLAUDE.md`, `.claude/` skills, agents, hooks |
  150. | Cursor | Compatible | `.cursorrules` + `.cursor/rules/` symlinked to source |
  151. | GitHub Copilot | Compatible | `.github/copilot-instructions.md` symlinked to source |
  152. | Windsurf | Compatible | `.windsurfrules` symlinked to source |
  153. | Cline | Compatible | `.clinerules` symlinked to source |
  154. | OpenAI Codex | Compatible | `AGENTS.md` with project context |
  155. All compatibility files are symlinks to `CLAUDE.md` (single source of truth). Rules in `.claude/rules/` are shared via symlinks where the tool supports directory-based rules.
  156. ## Documentation
  157. | Doc | What It Covers |
  158. |-----|----------------|
  159. | [START_HERE.md](START_HERE.md) | 10-step beginner guide |
  160. | [handbook/HELP_GUIDE.md](handbook/HELP_GUIDE.md) | Full command reference, workflows, and cheat sheet |
  161. | [handbook/ARCHITECTURE.md](handbook/ARCHITECTURE.md) | How PM-Kit works, project structure, principles |
  162. | [handbook/QMD_INTEGRATION.md](handbook/QMD_INTEGRATION.md) | QMD setup, troubleshooting, architecture |
  163. | [handbook/SETUP_GUIDE.md](handbook/SETUP_GUIDE.md) | Installation and first run |
  164. | [handbook/CUSTOMIZATION.md](handbook/CUSTOMIZATION.md) | Projects, templates, and overrides |
  165. | [handbook/WORKFLOW_EXAMPLES.md](handbook/WORKFLOW_EXAMPLES.md) | Example operating flows |
  166. | [handbook/TROUBLESHOOTING.md](handbook/TROUBLESHOOTING.md) | Common issues and fixes |
  167. | [handbook/maintainer-runbook.md](handbook/maintainer-runbook.md) | Release, changelog governance, and maintainer workflow |
  168. ## Contributing
  169. Contributions are welcome.
  170. - Read `CONTRIBUTING.md`
  171. - Use the PR template
  172. - Include a `## Changelog Entry` in each PR
  173. Every merged PR to `main` is automatically recorded in `CHANGELOG.md`.
  174. ## License
  175. MIT
  176. ## Star History
  177. [![Star History Chart](https://api.star-history.com/svg?repos=kv0906/pm-kit&type=Date)](https://star-history.com/#kv0906/pm-kit&Date)
  178. Think clearly. Build simply. Let systems carry the weight.
cli/install.sh · Bundled script · 201 lines · 1 finding marked
  1. #!/usr/bin/env bash
  2. # PM-Kit CLI Installer
  3. # Usage: curl -fsSL https://raw.githubusercontent.com/kv0906/pm-kit/main/cli/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 3 on GitHub
  4. set -euo pipefail
  5. # Colors
  6. RED='\033[0;31m'
  7. GREEN='\033[0;32m'
  8. YELLOW='\033[1;33m'
  9. CYAN='\033[0;36m'
  10. BOLD='\033[1m'
  11. NC='\033[0m'
  12. info() { echo -e "${CYAN}→${NC} $*"; }
  13. ok() { echo -e "${GREEN}✓${NC} $*"; }
  14. warn() { echo -e "${YELLOW}!${NC} $*"; }
  15. err() { echo -e "${RED}✗${NC} $*" >&2; }
  16. echo -e "${CYAN}${BOLD}"
  17. echo "╔═══════════════════════════════════════════════════╗"
  18. echo "║ PM-Kit CLI Installer ║"
  19. echo "╚═══════════════════════════════════════════════════╝"
  20. echo -e "${NC}"
  21. # --- Prerequisites ---
  22. for cmd in bash git curl tar; do
  23. if ! command -v "$cmd" >/dev/null 2>&1; then
  24. err "Required command not found: $cmd"
  25. exit 1
  26. fi
  27. done
  28. ok "Prerequisites: bash, git, curl, tar"
  29. # --- Platform ---
  30. OS="$(uname -s)"
  31. case "$OS" in
  32. Darwin) ok "Platform: macOS" ;;
  33. Linux) ok "Platform: Linux" ;;
  34. *) warn "Platform: $OS (untested, may work)" ;;
  35. esac
  36. # --- CLI home ---
  37. CLI_HOME="${PM_KIT_HOME:-$HOME/.pm-kit}"
  38. mkdir -p "$CLI_HOME/bin" "$CLI_HOME/lib"
  39. info "Installing to: $CLI_HOME"
  40. # --- Download latest release ---
  41. REPO_SLUG="kv0906/pm-kit"
  42. API_URL="https://api.github.com/repos/${REPO_SLUG}/releases/latest"
  43. info "Fetching latest release..."
  44. API_RESPONSE="$(curl -sS -w "\n%{http_code}" "$API_URL" 2>/dev/null)" || {
  45. err "Failed to reach GitHub API."
  46. exit 1
  47. }
  48. HTTP_CODE="$(echo "$API_RESPONSE" | tail -1)"
  49. API_BODY="$(echo "$API_RESPONSE" | sed '$d')"
  50. if [ "$HTTP_CODE" != "200" ]; then
  51. err "GitHub API returned $HTTP_CODE."
  52. exit 1
  53. fi
  54. REMOTE_TAG="$(echo "$API_BODY" | grep '"tag_name"' | head -1 | sed -E 's/.*"tag_name"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/')"
  55. TARBALL_URL="$(echo "$API_BODY" | grep '"tarball_url"' | head -1 | sed -E 's/.*"tarball_url"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/')"
  56. REMOTE_VERSION="${REMOTE_TAG#v}"
  57. if [ -z "$REMOTE_VERSION" ] || [ -z "$TARBALL_URL" ]; then
  58. err "Could not parse release info."
  59. exit 1
  60. fi
  61. ok "Latest version: v${REMOTE_VERSION}"
  62. # --- Download and extract ---
  63. TMPDIR_INSTALL="$(mktemp -d)"
  64. TARBALL="$TMPDIR_INSTALL/release.tar.gz"
  65. info "Downloading..."
  66. curl -sS -L -o "$TARBALL" "$TARBALL_URL" || {
  67. err "Download failed."
  68. rm -rf "$TMPDIR_INSTALL"
  69. exit 1
  70. }
  71. tar -xzf "$TARBALL" -C "$TMPDIR_INSTALL" || {
  72. err "Extraction failed."
  73. rm -rf "$TMPDIR_INSTALL"
  74. exit 1
  75. }
  76. EXTRACT_DIR="$(find "$TMPDIR_INSTALL" -mindepth 1 -maxdepth 1 -type d | head -1)"
  77. if [ -z "$EXTRACT_DIR" ]; then
  78. err "Could not find extracted directory."
  79. rm -rf "$TMPDIR_INSTALL"
  80. exit 1
  81. fi
  82. # --- Install CLI files ---
  83. CLI_SRC="$EXTRACT_DIR/cli"
  84. if [ ! -d "$CLI_SRC" ]; then
  85. err "Release does not contain cli/ directory."
  86. err "This release may predate the CLI. Check for a newer release."
  87. rm -rf "$TMPDIR_INSTALL"
  88. exit 1
  89. fi
  90. info "Installing CLI..."
  91. cp "$CLI_SRC/bin/pm-kit" "$CLI_HOME/bin/pm-kit"
  92. chmod +x "$CLI_HOME/bin/pm-kit"
  93. # Copy lib files
  94. rm -rf "$CLI_HOME/lib"
  95. cp -R "$CLI_SRC/lib" "$CLI_HOME/lib"
  96. # Copy install.sh for reference
  97. cp "$CLI_SRC/install.sh" "$CLI_HOME/install.sh" 2>/dev/null || true
  98. # Write VERSION
  99. echo "$REMOTE_VERSION" > "$CLI_HOME/VERSION"
  100. # Initialize update check timer
  101. date +%s > "$CLI_HOME/.last-update-check"
  102. ok "CLI installed to $CLI_HOME"
  103. # --- Cleanup ---
  104. rm -rf "$TMPDIR_INSTALL"
  105. # --- Add to PATH ---
  106. BIN_DIR="$CLI_HOME/bin"
  107. PATH_LINE="export PATH=\"$BIN_DIR:\$PATH\""
  108. add_to_path() {
  109. local rc_file="$1"
  110. if [ -f "$rc_file" ]; then
  111. if grep -q "$BIN_DIR" "$rc_file" 2>/dev/null; then
  112. return 0 # Already present
  113. fi
  114. fi
  115. echo "" >> "$rc_file"
  116. echo "# PM-Kit CLI" >> "$rc_file"
  117. echo "$PATH_LINE" >> "$rc_file"
  118. return 1 # Added
  119. }
  120. SHELL_NAME="$(basename "$SHELL")"
  121. ADDED_TO=""
  122. case "$SHELL_NAME" in
  123. zsh)
  124. add_to_path "$HOME/.zshrc" || ADDED_TO="$HOME/.zshrc"
  125. ;;
  126. bash)
  127. if [ -f "$HOME/.bash_profile" ]; then
  128. add_to_path "$HOME/.bash_profile" || ADDED_TO="$HOME/.bash_profile"
  129. else
  130. add_to_path "$HOME/.bashrc" || ADDED_TO="$HOME/.bashrc"
  131. fi
  132. ;;
  133. *)
  134. add_to_path "$HOME/.profile" || ADDED_TO="$HOME/.profile"
  135. ;;
  136. esac
  137. # --- Success ---
  138. echo ""
  139. echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
  140. echo -e "${GREEN} PM-Kit CLI installed! (v${REMOTE_VERSION})${NC}"
  141. echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
  142. echo ""
  143. if [ -n "$ADDED_TO" ]; then
  144. info "Added to PATH in $ADDED_TO"
  145. echo ""
  146. echo "To use immediately, run:"
  147. echo " source $ADDED_TO"
  148. echo ""
  149. fi
  150. echo "Get started:"
  151. echo " pm-kit init # Create a new vault"
  152. echo " pm-kit help # See all commands"
  153. echo ""
  154. echo "Or from an existing vault:"
  155. echo " cd /path/to/vault"
  156. echo " pm-kit migrate # Convert to CLI-managed"
  157. echo " pm-kit doctor # Check vault health"

Ratings and comments

Sign in to rate this skill.

Sign in

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