renderdeck-mcp 0.1.0__tar.gz

renderdeck_mcp-0.1.0/.claude/commands/feedback.md

@@ -0,0 +1,53 @@
+# /sdd feedback - Agent Feedback Collection
+
+Collect structured feedback on agent performance and route to learnings.
+
+## Usage
+
+```
+/sdd feedback [agent-name]
+```
+
+## Agents
+
+| Agent | Feedback After |
+|-------|---------------|
+| init | Project initialization |
+| best-practices | Best practices generation |
+| project-goal | Goal definition |
+| project-manager | Epic/task planning |
+| designer | Design phase |
+| test-writer | Test writing |
+| implementer | Implementation |
+| reviewer | Code review |
+| completeness-reviewer | Completeness checks |
+| challenger | Challenge reports |
+| orchestrator | Automated pipeline runs |
+| bug-analyst | Bug investigation |
+| bug-test-writer | Bug regression tests |
+| bug-implementer | Bug fix implementation |
+| bug-reviewer | Bug fix review |
+
+## Workflow
+
+1. Invoke the `sdd-feedback` skill
+2. Walk through structured feedback form:
+   - Target agent
+   - Feedback type (BUG/GAP/QUALITY/PROCESS/PRAISE)
+   - Severity (CRITICAL/WARNING/INFO)
+   - Description
+   - Expected behavior
+   - Affected files
+   - Should this be a recurring check?
+3. Route feedback to agent's `learnings/{agent}-lessons.json`
+4. Detect patterns (3+ similar → propose best-practices update)
+5. Report confirmation
+
+## Example
+
+```
+/sdd feedback designer
+# → Walks through feedback form
+# → Routes to .claude/skills/sdd-designer/learnings/designer-lessons.json
+# → Reports pattern detection results
+```

renderdeck_mcp-0.1.0/.claude/commands/sdd.md

@@ -0,0 +1,287 @@
+# /sdd - Spec-Driven Development
+
+Orchestrate feature development through structured phases with automated quality gates.
+
+## Usage
+
+```
+/sdd [command] [arguments]
+```
+
+## Commands
+
+### Project Setup
+
+| Command | Description |
+|---------|-------------|
+| `/sdd init` | Run project questionnaire, generate config and docs (produces `project-init.yaml`, `tech-stack.md`, `sdd-config.yaml`, `AGENTS.md`) |
+| `/sdd best-practices` | Generate project-specific coding best practices |
+| `/sdd goal` | Define measurable project goals and success criteria |
+| `/sdd setup` | Diagnose quality tooling, validate tool availability, check git access |
+| `/sdd setup-project` | One-time project setup: analyzes codebase via Bitbucket, generates goal, creates epics and tasks, syncs all to Jira |
+
+### Planning
+
+| Command | Description |
+|---------|-------------|
+| `/sdd plan [project]` | Create epics and tasks (Project Manager) |
+| `/sdd challenge [target]` | Devil's advocate review. Targets: `epics` (challenge epics list), `epic-{name}` (challenge tasks for a specific epic) |
+| `/sdd sync-jira` | Sync all epics and tasks to Jira (idempotent — safe to run multiple times) |
+
+### Development Phases
+
+| Command | Description |
+|---------|-------------|
+| `/sdd design [feature]` | Create design docs and handoffs |
+| `/sdd unit-test [feature]` | Write unit tests from design handoffs (pure functions, no I/O) |
+| `/sdd integration-test [feature]` | Write integration tests from design handoffs (API, DB, service boundaries) |
+| `/sdd impl [feature]` | Write code to pass tests |
+| `/sdd review [feature]` | Review implementation |
+
+### Bug Pipeline
+
+| Command | Description |
+|---------|-------------|
+| `/sdd bug <bug-reference>` | Start bug fix pipeline via `sdd-bug-orchestrator` (Bug Analyst → Bug Test-Writer → Bug Implementer → Bug Reviewer) |
+| `/sdd fix <bug-reference>` | Alias for `/sdd bug` |
+| `/sdd bug <bug-reference> --resume` | Resume bug pipeline from last in_progress phase |
+
+### Automation
+
+| Command | Description |
+|---------|-------------|
+| `/sdd task <jira-id\|task-slug>` | Run full 19-phase pipeline for a single task in fresh context (e.g. `/sdd task NCI-43` or `/sdd task my-feature`) |
+| `/sdd task <id> --turbo` | Run pipeline in turbo mode (auto-approve checkpoints except security) |
+| `/sdd task <id> --resume` | Resume pipeline from last in_progress phase |
+| `/sdd turbo [task-id\|all]` | Script-driven turbo mode via `claude --print`. Prints instructions for running `bash .claude/scripts/sdd-pipeline-runner.sh` |
+
+### Independent Review
+For an unbiased review after fixing gaps, spawn the reviewer with fresh context:
+- `/sdd review --fresh` — Spawns reviewer as a new Task (isolated context)
+- Recommended when re-checking artifacts after addressing gaps in the same session
+
+### Quality & Feedback
+
+| Command | Description |
+|---------|-------------|
+| `/sdd feedback [agent]` | Provide structured feedback on an agent |
+
+### Recovery & Troubleshooting
+
+| Command | Description |
+|---------|-------------|
+| `/sdd doctor` | Validate SDD setup (check required files, config, tools) |
+| `/sdd reset` | Reset SDD state (default: operational state only) |
+| `/sdd reset --full` | Remove ALL generated artifacts (state + docs + branches) |
+| `/sdd reset --dry-run` | Preview what would be deleted without doing it |
+| `/sdd unlock` | Remove stale pipeline locks (also done by reset) |
+| `/sdd rollback` | Revert last auto-commit |
+
+#### /sdd doctor
+Validate SDD setup and report issues. Run these checks:
+```bash
+# Check dependencies
+command -v python3 && echo "✓ python3" || echo "✗ python3 missing"
+command -v jq && echo "✓ jq" || echo "✗ jq missing"
+# Check config
+[ -f sdd-config.yaml ] && echo "✓ sdd-config.yaml" || echo "✗ sdd-config.yaml missing"
+# Check state
+[ -f docs/sdd/state.json ] && echo "✓ state.json" || echo "✗ state.json missing"
+# Check lock
+[ -d docs/sdd/lock ] && echo "⚠ Lock exists (orchestrator running or stale)" || echo "✓ No lock"
+# Check hooks
+[ -f .claude/settings.json ] && echo "✓ settings.json" || echo "✗ settings.json missing"
+```
+
+#### /sdd reset
+Reset SDD workflow state and generated artifacts.
+
+**Levels:**
+| Level | What it removes | What it keeps |
+|-------|----------------|---------------|
+| `state` (default) | state.json, lock, validation, jira-logs, health, turbo, context-digest, feedback, per-task artifact dirs | Project docs, architecture, branches, config, archive |
+| `full` | Everything above + project docs, architecture, jira-mapping, worktrees, sdd/\* and bugfix/\* branches | .claude/ framework, sdd-config.yaml, best-practices.md, tech-stack.md, getting-started/, quality/, archive/ |
+
+**Usage:**
+```bash
+# Preview what would be deleted (no changes)
+bash .claude/scripts/sdd-reset.sh --dry-run
+
+# Reset operational state only (default)
+bash .claude/scripts/sdd-reset.sh
+
+# Full reset — remove all generated artifacts
+bash .claude/scripts/sdd-reset.sh --level full
+
+# Skip confirmation prompt
+bash .claude/scripts/sdd-reset.sh --level full --yes
+```
+
+**Note:** Learnings files (`.claude/skills/sdd-*/learnings/`) and `docs/sdd/archive/` are preserved at all levels — learnings are self-managing framework knowledge, and archive contains user-curated snapshots.
+
+When invoked as `/sdd reset`, run the script with the appropriate flags:
+- `/sdd reset` → `bash .claude/scripts/sdd-reset.sh`
+- `/sdd reset --full` → `bash .claude/scripts/sdd-reset.sh --full`
+- `/sdd reset --dry-run` → `bash .claude/scripts/sdd-reset.sh --dry-run`
+- `/sdd reset --full --dry-run` → `bash .claude/scripts/sdd-reset.sh --full --dry-run`
+
+#### /sdd unlock
+Remove stale orchestrator lock:
+```bash
+rm -rf docs/sdd/lock
+echo "Lock removed. Verify no other orchestrator is running before proceeding."
+```
+
+#### /sdd rollback
+Revert the last auto-commit (only if it was an SDD commit):
+```bash
+# Check last commit message
+last_msg=$(git log -1 --pretty=%s)
+if [[ "$last_msg" == "[SDD]"* ]]; then
+  git revert HEAD --no-edit
+  echo "Reverted: $last_msg"
+else
+  echo "Last commit is not an SDD auto-commit: $last_msg"
+  echo "Manual revert required."
+fi
+```
+
+## Quick Start
+
+### Manual Workflow
+```
+/sdd init                    # Setup project
+/sdd best-practices          # Generate coding standards
+/sdd goal                    # Define success criteria
+/sdd plan my-project         # Create epics
+/sdd challenge epics         # Review epics
+/sdd design my-feature       # Design phase
+/sdd unit-test my-feature    # Unit test phase
+/sdd integration-test my-feature  # Integration test phase
+/sdd impl my-feature         # Implementation phase
+/sdd review my-feature       # Review phase
+```
+
+### Automated Workflow
+```
+/sdd setup-project           # One-time setup: analyze codebase, generate goals, create epics/tasks, sync to Jira
+/sdd task NCI-43             # Run full pipeline for a single task (fresh context)
+                             # Or: /sdd turbo all  (script-driven, no human checkpoints)
+```
+
+## Workflow
+
+### Manual Pipeline
+```
+Init → Best Practices → Goal → Plan → Challenge → Design → Unit Tests → Integration Tests → Implement → Review
+```
+
+### Automated Pipeline
+
+#### Entry Points
+
+| Command | Entry Point | Scope |
+|---------|-------------|-------|
+| `/sdd setup-project` | Codebase analysis → Goal → Epics → Tasks → Jira sync | Full project init (one-time) |
+| `/sdd task <id>` | Single task 19-phase pipeline (fresh context) | One task |
+| `/sdd turbo [id\|all]` | Script-driven via `claude --print`, no human checkpoints | One task or all tasks |
+
+#### Full Task Pipeline (via `/sdd task` or `/sdd turbo`)
+```
+Designer → Validation Loop → Challenger (tech+security) →
+Security Review (design) →
+★HUMAN CHECKPOINT: Design+Security (Pre-Reveal → Reveal → Decide; risk-routed) →
+Unit Tests → Validation Loop →
+Integration Tests → Validation Loop →
+★HUMAN CHECKPOINT: Tests (Pre-Reveal → Reveal → Decide; risk-routed) →
+Impl → Coverage Check → SAST Gate → Mutation Test → Validation Loop →
+Security Review (impl) + Aikido →
+★HUMAN CHECKPOINT: Impl+Security (Pre-Reveal → Reveal → Decide; risk-routed) →
+Code Review → Feedback Collector
+```
+
+### Automated Bug Pipeline (via `/sdd bug` or `/sdd fix` → `sdd-bug-orchestrator`)
+```
+Init → [Jira: In Progress] →
+Bug Analyst → Validation Loop → ★HUMAN CHECKPOINT (Pre-Reveal → Reveal → Decide; always full) →
+Bug Test-Writer → Validation Loop →
+Bug Implementer → Validation Loop → [Security Review (if auth/authz/validation touched)] →
+★HUMAN CHECKPOINT (Pre-Reveal → Reveal → Decide; always full) →
+Bug Reviewer → Feedback Collector → Git PR → [Jira: In Review]
+```
+
+Each phase:
+1. Loads context from previous phase
+2. Produces artifacts in `docs/sdd/{epic}/{task}/`
+3. Completeness review catches gaps
+4. Stops and waits for user (manual) or auto-advances (orchestrated)
+
+## Artifacts Location
+
+```
+docs/
+├── sdd/
+│   ├── context-digest.md            # Compact routing context and non-negotiables
+│   ├── phase-index.md               # Current epic/task/phase pointers
+│   ├── state.json                   # Orchestrator state
+│   ├── health.yaml                  # Quality metrics and agent run stats
+│   ├── feedback/                    # Structured feedback storage
+│   ├── lock/                        # Orchestrator exclusivity lock
+│   └── {epic}/{task}/               # Per-task artifacts:
+│       ├── design.md                #   Design document
+│       ├── test-handoff.md          #   Designer → Test-Writer handoff
+│       ├── unit-tests.md            #   Unit test plan
+│       ├── integration-tests.md     #   Integration test plan
+│       ├── impl-handoff.md          #   Test-Writer → Implementer handoff
+│       ├── review-handoff.md        #   Implementer → Reviewer handoff
+│       ├── review.md                #   Code review report
+│       ├── security-design-report.md  #   Security review (design phase)
+│       ├── security-impl-report.md    #   Security review (implementation phase)
+│       ├── bug-analysis.md          #   Bug analysis (bug pipeline only)
+│       └── {phase}-completeness.md  #   Completeness review per phase
+├── project/                         # Project management artifacts
+│   ├── project-init.yaml
+│   ├── project-goal.md
+│   ├── epics_list.md
+│   ├── epic-{name}/
+│   └── challenges/
+├── best-practices.md                # Project-specific coding standards
+└── tech-stack.md                    # Technology choices
+```
+
+## Agents
+
+| Agent | Phase |
+|-------|-------|
+| `sdd-project-setup` | One-time project setup orchestrator |
+| `sdd-init` | Project initialization |
+| `sdd-setup` | Project tooling diagnosis and validation |
+| `sdd-best-practices` | Best practices generation |
+| `sdd-project-goal` | Goal definition |
+| `sdd-project-manager` | Epic/task planning |
+| `sdd-jira-sync` | Jira epic/task sync |
+| `sdd-challenger` | Devil's advocate (multi-perspective) |
+| `sdd-task-orchestrator` | Single-task 19-phase pipeline |
+| `sdd-designer` | Design phase |
+| `sdd-security-reviewer` | Security review (design + implementation) |
+| `sdd-unit-test-writer` | Unit test phase (no I/O) |
+| `sdd-integration-test-writer` | Integration test phase (component boundaries) |
+| `sdd-implementer` | Implementation phase |
+| `sdd-reviewer` | Code review |
+| `sdd-completeness-reviewer` | Quality gates |
+| `sdd-feedback` | Feedback collection |
+| `sdd-bug-orchestrator` | Bug fix pipeline |
+| `sdd-bug-analyst` | Bug investigation and root cause analysis |
+| `sdd-bug-test-writer` | Bug regression test writing |
+| `sdd-bug-implementer` | Bug fix implementation |
+| `sdd-bug-reviewer` | Bug fix review |
+
+
+## Tips
+
+- Each phase is independent - you can re-run any phase
+- Handoffs bridge phases - check them if confused
+- Don't skip phases - tests before code, design before tests
+- Use `/sdd feedback` after any phase to improve agents over time
+- Use `/sdd task <jira-id>` for single-task hands-off development (pauses only at checkpoints)
+- Use `/sdd turbo all` for fully script-driven execution with no human checkpoints

renderdeck_mcp-0.1.0/.claude/hooks/git/pre-commit

@@ -0,0 +1,120 @@
+#!/usr/bin/env bash
+# SDD Framework pre-commit hook — enforces version bumps for .claude/ changes
+# Installed to .git/hooks/pre-commit by sdd-setup-hooks.sh
+# Compatible with bash 3.x (macOS default)
+set -euo pipefail
+
+VERSION_FILE="VERSION"
+ERRORS=()
+
+# Get staged files (--no-renames ensures renames appear as delete+add, not R status)
+STAGED_FILES="$(git diff --cached --no-renames --name-only)"
+if [[ -z "$STAGED_FILES" ]]; then
+  exit 0
+fi
+
+# Filter to qualifying .claude/ files (exclude learnings)
+QUALIFYING_FILES=()
+while IFS= read -r file; do
+  [[ "$file" == .claude/* ]] || continue
+  [[ "$file" == .claude/skills/sdd-*/learnings/*.json ]] && continue
+  QUALIFYING_FILES+=("$file")
+done <<< "$STAGED_FILES"
+
+# No qualifying .claude/ files → nothing to check
+if [[ ${#QUALIFYING_FILES[@]} -eq 0 ]]; then
+  exit 0
+fi
+
+# Collect unique skills with changes (bash 3 compatible — no associative arrays)
+CHANGED_SKILLS=""
+for file in "${QUALIFYING_FILES[@]}"; do
+  if [[ "$file" =~ ^\.claude/skills/(sdd-[^/]+)/ ]]; then
+    skill="${BASH_REMATCH[1]}"
+    # Dedup: only add if not already in the list
+    if ! echo "$CHANGED_SKILLS" | grep -qx "$skill"; then
+      CHANGED_SKILLS="${CHANGED_SKILLS}${CHANGED_SKILLS:+$'\n'}${skill}"
+    fi
+  fi
+done
+
+# Check each changed skill
+if [[ -n "$CHANGED_SKILLS" ]]; then
+  while IFS= read -r skill_name; do
+    [[ -n "$skill_name" ]] || continue
+    skill_file=".claude/skills/$skill_name/SKILL.md"
+
+    # Skip deleted/renamed-away skills (SKILL.md removed or renamed to another skill)
+    if git diff --cached --no-renames --diff-filter=D --name-only | grep -qx "$skill_file"; then
+      continue
+    fi
+
+    # Check if SKILL.md is staged
+    if ! echo "$STAGED_FILES" | grep -qx "$skill_file"; then
+      ERRORS+=("Skill '$skill_name' has changed files but SKILL.md is not staged.")
+      ERRORS+=("  Fix: .claude/scripts/sdd-bump-version.sh skill $skill_name patch && git add $skill_file")
+      continue
+    fi
+
+    # For new files (no HEAD version), any version is fine
+    head_version="$(git show HEAD:"$skill_file" 2>/dev/null | grep -m1 '^version:' | sed 's/^version:[[:space:]]*//' || echo "")"
+    if [[ -z "$head_version" ]]; then
+      continue
+    fi
+
+    # Compare staged version vs HEAD version
+    staged_version="$(git diff --cached -- "$skill_file" | grep -m1 '^+version:' | sed 's/^+version:[[:space:]]*//' || echo "")"
+    if [[ -z "$staged_version" ]]; then
+      # version line wasn't changed in the diff — versions are equal
+      ERRORS+=("Skill '$skill_name' version not bumped (still $head_version).")
+      ERRORS+=("  Fix: .claude/scripts/sdd-bump-version.sh skill $skill_name patch && git add $skill_file")
+    fi
+  done <<< "$CHANGED_SKILLS"
+fi
+
+# Check project-level VERSION
+head_proj="$(git show HEAD:"$VERSION_FILE" 2>/dev/null | tr -d '[:space:]' || echo "")"
+
+if ! echo "$STAGED_FILES" | grep -qx "$VERSION_FILE"; then
+  ERRORS+=("VERSION not staged but .claude/ files changed.")
+  ERRORS+=("  Fix: .claude/scripts/sdd-bump-version.sh project patch && git add VERSION")
+elif [[ -n "$head_proj" ]]; then
+  staged_proj="$(git diff --cached -- "$VERSION_FILE" | grep '^+' | grep -v '^+++' | head -1 | sed 's/^+//' | tr -d '[:space:]' || echo "")"
+  if [[ -z "$staged_proj" ]]; then
+    ERRORS+=("VERSION not bumped (still $head_proj).")
+    ERRORS+=("  Fix: .claude/scripts/sdd-bump-version.sh project patch && git add VERSION")
+  fi
+fi
+
+# Check CHANGELOG.md is staged when VERSION is bumped
+if echo "$STAGED_FILES" | grep -qx "$VERSION_FILE"; then
+  if ! echo "$STAGED_FILES" | grep -qx "CHANGELOG.md"; then
+    ERRORS+=("CHANGELOG.md not staged but VERSION was bumped.")
+    ERRORS+=("  Fix: .claude/scripts/sdd-bump-version.sh auto (includes changelog update)")
+  else
+    # Check that CHANGELOG.md actually has a new entry (not just the old content)
+    changelog_diff="$(git diff --cached -- CHANGELOG.md | grep '^+##' | grep -v '^+++' || true)"
+    if [[ -z "$changelog_diff" ]]; then
+      ERRORS+=("CHANGELOG.md is staged but has no new version entry.")
+      ERRORS+=("  Fix: Add a ## [x.y.z] entry to CHANGELOG.md, or run: .claude/scripts/sdd-bump-version.sh auto")
+    fi
+  fi
+fi
+
+# Report
+if [[ ${#ERRORS[@]} -gt 0 ]]; then
+  echo ""
+  echo "╔══════════════════════════════════════════════════════╗"
+  echo "║  SDD Version Check Failed                           ║"
+  echo "╠══════════════════════════════════════════════════════╣"
+  for err in "${ERRORS[@]}"; do
+    echo "║  $err"
+  done
+  echo "║"
+  echo "║  Quick fix: .claude/scripts/sdd-bump-version.sh auto"
+  echo "╚══════════════════════════════════════════════════════╝"
+  echo ""
+  exit 1
+fi
+
+exit 0