cc-discipline 2.0.0 → 2.2.0

package/init.sh

@@ -7,8 +7,12 @@
 
 set -e
 
-# ─── Version ───
-VERSION="2.0.0"
+# ─── Version (single source: package.json) ───
+_INIT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if command -v node &>/dev/null && [ -f "$_INIT_DIR/package.json" ]; then
+    VERSION=$(node -p "require('$_INIT_DIR/package.json').version" 2>/dev/null)
+fi
+VERSION="${VERSION:-unknown}"
 
 # ─── Parse CLI arguments ───
 ARG_STACK=""
@@ -355,9 +359,13 @@ echo -e "${GREEN}Installing skills...${NC}"
 cp -r "$SCRIPT_DIR/templates/.claude/skills/commit" .claude/skills/
 cp -r "$SCRIPT_DIR/templates/.claude/skills/self-check" .claude/skills/
 cp -r "$SCRIPT_DIR/templates/.claude/skills/evaluate" .claude/skills/
+cp -r "$SCRIPT_DIR/templates/.claude/skills/think" .claude/skills/
+cp -r "$SCRIPT_DIR/templates/.claude/skills/retro" .claude/skills/
 echo "   ✓ /commit — smart commit (test → update memory → commit)"
 echo "   ✓ /self-check — periodic discipline check (use with /loop 10m /self-check)"
 echo "   ✓ /evaluate — evaluate external review/advice against codebase context"
+echo "   ✓ /think — stop and think before coding (ask → propose → wait)"
+echo "   ✓ /retro — post-task retrospective (project + framework feedback)"
 
 # ─── Handle CLAUDE.md ───
 if [ ! -f "CLAUDE.md" ]; then
@@ -386,16 +394,45 @@ if [ ! -f "docs/debug-log.md" ]; then
     cp "$SCRIPT_DIR/templates/docs/debug-log.md" docs/
 fi
 
-# ─── Install auto memory ───
+# ─── Install auto memory (symlink to .claude/memory/) ───
 echo -e "${GREEN}Installing auto memory...${NC}"
 MEMORY_PROJECT_KEY=$(echo "$PROJECT_DIR" | sed 's|/|-|g')
-MEMORY_DIR="$HOME/.claude/projects/${MEMORY_PROJECT_KEY}/memory"
-mkdir -p "$MEMORY_DIR"
-if [ ! -f "$MEMORY_DIR/MEMORY.md" ]; then
-    cp "$SCRIPT_DIR/templates/memory/MEMORY.md" "$MEMORY_DIR/MEMORY.md"
-    echo "   ✓ Memory installed to $MEMORY_DIR/MEMORY.md"
+MEMORY_CLAUDE_DIR="$HOME/.claude/projects/${MEMORY_PROJECT_KEY}"
+MEMORY_LOCAL_DIR="$PROJECT_DIR/.claude/memory"
+
+# Ensure local .claude/memory/ exists in repo
+mkdir -p "$MEMORY_LOCAL_DIR"
+
+# If MEMORY.md doesn't exist locally, seed from template
+if [ ! -f "$MEMORY_LOCAL_DIR/MEMORY.md" ]; then
+    cp "$SCRIPT_DIR/templates/memory/MEMORY.md" "$MEMORY_LOCAL_DIR/MEMORY.md"
+    echo "   ✓ Memory template installed to .claude/memory/MEMORY.md"
+else
+    echo -e "   ${YELLOW}.claude/memory/MEMORY.md already exists (preserved)${NC}"
+fi
+
+# Create symlink: ~/.claude/projects/<key>/memory → .claude/memory/
+mkdir -p "$MEMORY_CLAUDE_DIR"
+if [ -L "$MEMORY_CLAUDE_DIR/memory" ]; then
+    # Symlink already exists — update it
+    rm "$MEMORY_CLAUDE_DIR/memory"
+    ln -s "$MEMORY_LOCAL_DIR" "$MEMORY_CLAUDE_DIR/memory"
+    echo "   ✓ Memory symlink updated"
+elif [ -d "$MEMORY_CLAUDE_DIR/memory" ]; then
+    # Existing real directory — migrate files then replace with symlink
+    for f in "$MEMORY_CLAUDE_DIR/memory/"*; do
+        [ -f "$f" ] || continue
+        fname=$(basename "$f")
+        if [ ! -f "$MEMORY_LOCAL_DIR/$fname" ]; then
+            cp "$f" "$MEMORY_LOCAL_DIR/$fname"
+        fi
+    done
+    rm -rf "$MEMORY_CLAUDE_DIR/memory"
+    ln -s "$MEMORY_LOCAL_DIR" "$MEMORY_CLAUDE_DIR/memory"
+    echo "   ✓ Existing memory migrated to .claude/memory/ and symlinked"
 else
-    echo -e "   ${YELLOW}MEMORY.md already exists, skipping (no overwrite)${NC}"
+    ln -s "$MEMORY_LOCAL_DIR" "$MEMORY_CLAUDE_DIR/memory"
+    echo "   ✓ Memory symlinked: ~/.claude/projects/.../ → .claude/memory/"
 fi
 
 # ─── Install global rules (optional) ───
@@ -437,10 +474,12 @@ if [ "$INSTALL_MODE" = "fresh" ]; then
     echo -e "  ${GREEN}.claude/skills/commit/${NC}       ← /commit smart commit"
     echo -e "  ${GREEN}.claude/skills/self-check/${NC}   ← /self-check periodic discipline check"
     echo -e "  ${GREEN}.claude/skills/evaluate/${NC}     ← /evaluate assess external review advice"
+    echo -e "  ${GREEN}.claude/skills/think/${NC}        ← /think stop and think before coding"
+    echo -e "  ${GREEN}.claude/skills/retro/${NC}        ← /retro post-task retrospective"
     echo -e "  ${GREEN}.claude/settings.json${NC}        ← Hooks configuration"
     echo -e "  ${GREEN}docs/progress.md${NC}             ← Progress log (maintained by Claude)"
     echo -e "  ${GREEN}docs/debug-log.md${NC}            ← Debug log (maintained by Claude)"
-    echo -e "  ${GREEN}~/.claude/projects/.../memory/${NC} ← Auto memory (cross-session)"
+    echo -e "  ${GREEN}.claude/memory/${NC}              ← Auto memory (symlinked, lives in repo)"
     echo ""
     echo -e "${YELLOW}Next steps:${NC}"
     echo "  1. Edit CLAUDE.md and fill in the [TODO] sections with project info"
@@ -455,6 +494,8 @@ else
     echo -e "  ${GREEN}.claude/skills/commit/${NC}       ← /commit skill installed/updated"
     echo -e "  ${GREEN}.claude/skills/self-check/${NC}   ← /self-check discipline check installed"
     echo -e "  ${GREEN}.claude/skills/evaluate/${NC}     ← /evaluate external review assessment"
+    echo -e "  ${GREEN}.claude/skills/think/${NC}        ← /think stop and think before coding"
+    echo -e "  ${GREEN}.claude/skills/retro/${NC}        ← /retro post-task retrospective"
     if [ ! -f "$BACKUP_DIR/settings.json" ] || [ -f ".claude/.cc-discipline-settings-template.json" ]; then
         echo -e "  ${YELLOW}.claude/settings.json${NC}        ← See notes above"
     else

package/lib/doctor.sh

@@ -95,7 +95,7 @@ done
 # 6. Skills
 echo ""
 echo "Skills:"
-for skill in commit self-check evaluate; do
+for skill in commit self-check evaluate think retro; do
     if [ -d ".claude/skills/${skill}" ]; then
         ok "/${skill}"
     else

package/lib/status.sh

@@ -68,8 +68,10 @@ SKILLS=""
 [ -d ".claude/skills/commit" ] && SKILLS="${SKILLS}/commit "
 [ -d ".claude/skills/self-check" ] && SKILLS="${SKILLS}/self-check "
 [ -d ".claude/skills/evaluate" ] && SKILLS="${SKILLS}/evaluate "
+[ -d ".claude/skills/think" ] && SKILLS="${SKILLS}/think "
+[ -d ".claude/skills/retro" ] && SKILLS="${SKILLS}/retro "
 SKILL_COUNT=$(echo "$SKILLS" | wc -w | tr -d ' ')
-echo -e "${GREEN}${SKILL_COUNT}/3${NC} (${SKILLS% })"
+echo -e "${GREEN}${SKILL_COUNT}/5${NC} (${SKILLS% })"
 
 # Settings
 echo -n "Settings: "

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "cc-discipline",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Discipline framework for Claude Code — rules, hooks, and agents that keep AI on track",
   "bin": {
-    "cc-discipline": "./bin/cli.sh"
+    "cc-discipline": "bin/cli.sh"
   },
   "files": [
     "bin/",
@@ -28,7 +28,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/techhu/cc-discipline"
+    "url": "git+https://github.com/techhu/cc-discipline.git"
   },
   "homepage": "https://github.com/techhu/cc-discipline#readme"
 }

package/templates/.claude/hooks/action-counter.sh

@@ -21,7 +21,7 @@ echo "$COUNT" > "$COUNT_FILE"
 
 if [ $((COUNT % THRESHOLD)) -eq 0 ]; then
     cat <<JSONEOF
-{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":"AUTO SELF-CHECK (#${COUNT} actions): Pause and verify: (1) Am I still serving the user's original request, or have I drifted? (2) Am I fixing the same thing repeatedly (mole-whacking)? (3) Have I claimed anything as 'verified' without actually running it? (4) Am I making changes the user didn't ask for? (5) Have I updated docs/progress.md with current status and completed milestones? If progress.md is stale, update it NOW before continuing. If ANY answer is concerning, STOP and report to the user before continuing."}}
+{"hookSpecificOutput":{"hookEventName":"PreToolUse","additionalContext":"AUTO SELF-CHECK (#${COUNT} actions): Pause and verify: (1) Am I still serving the user's original request, or have I drifted? (2) Am I fixing the same thing repeatedly (mole-whacking)? (3) Have I claimed anything as 'verified' without actually running it? (4) Am I making changes the user didn't ask for? (5) Have I updated docs/progress.md with current status and completed milestones? If progress.md is stale, update it NOW before continuing. (6) Plan fidelity: if executing a plan, compare what the current step asked for vs what I actually delivered — am I cutting corners or simplifying the intent? Check the acceptance criteria. (7) Friction check: did any hook/rule get in the way or miss something since last check? If so, note it in one line for /retro later. If ANY answer is concerning, STOP and report to the user before continuing."}}
 JSONEOF
 fi
 

package/templates/.claude/skills/retro/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: retro
+description: Find friction, remove friction. Quick post-task review that makes this project's workflow smoother and feeds improvements back to cc-discipline.
+---
+
+Find friction. Remove friction. That's it.
+
+## What to do
+
+Quickly scan what just happened — `git log --oneline -10` and any hook triggers you remember. Then output **only friction and insights**, in this format:
+
+```
+RETRO — [date]
+
+Friction:
+- [what got in the way] → fix: [specific actionable change]
+
+Insights:
+- [something learned that should survive this session]
+
+Framework:
+- [cc-discipline improvement, if any — skip if none]
+```
+
+Rules:
+- **Only friction** — Don't list what went well. Smooth things don't need attention.
+- **Only actionable** — Every friction item must have a "→ fix:" with a concrete change (adjust a threshold, add to CLAUDE.md, update memory, exempt a path).
+- **Only new** — Don't repeat friction that's already been addressed or recorded in memory.
+- **Be specific** — "streak-breaker was annoying" is not useful. "streak-breaker triggered 3x on config.yaml during template fill → fix: add config.yaml to docs/ exempt path, or raise config threshold to 10" is useful.
+- **Framework items are rare** — Most friction is project-specific. Only flag framework issues if the same problem would hit other projects too.
+- **Keep it short** — 3-5 items max. If you can't find friction, say "no friction found" and move on. An empty retro is a good sign.
+
+## After output
+
+Present the items. User decides:
+- "fix it" → apply the changes
+- "remember it" → write to memory via /commit
+- "skip" → move on
+
+Do not auto-apply. Do not pad. Do not turn this into a report.

package/templates/.claude/skills/think/SKILL.md

@@ -0,0 +1,104 @@
+---
+name: think
+description: Stop and think before coding. Read context, ask questions, propose approaches, self-review, wait for user choice. Use when starting any non-trivial task.
+---
+
+You are about to start a task. **Do NOT write any code yet.** Your job right now is to think clearly and align with the user before acting.
+
+## Step 0: Read first
+
+Before asking anything, read the relevant code and docs. Spend 1-2 minutes understanding what already exists:
+- Read files that will be affected
+- Check existing patterns, conventions, and architecture
+- Look at recent commits for context on current direction
+
+This turns your questions from generic ("what framework?") into informed ("I see you're using X pattern in module Y — should the new feature follow the same pattern, or is there a reason to diverge?").
+
+**Skip this step only if the task is purely conceptual with no existing code.**
+
+## Step 1: Gauge complexity
+
+Before diving deep, assess the task size:
+
+- **Small** (rename, fix typo, add a config field): Skip to Step 4 — just state what you'll do and do it. Don't over-process trivial work.
+- **Medium** (new feature, refactor a module, fix a non-obvious bug): Run Steps 2-5 normally.
+- **Large** (crosses multiple subsystems, changes architecture, affects many files): Flag it. Propose decomposition into smaller tasks before designing a monolith solution.
+
+State your assessment: "This looks [small/medium/large] because [reason]."
+
+## Step 2: Understand
+
+Ask 2-3 clarifying questions about the task. Focus on:
+- What exactly should change? (scope)
+- What should NOT change? (boundaries)
+- How will we know it's done? (success criteria)
+
+Rules:
+- One message, all questions at once (don't drip-feed)
+- Prefer multiple-choice over open-ended when possible
+- Reference what you learned in Step 0 — ask about gaps in your understanding, not things you can read yourself
+- If the task is already crystal clear from Step 0, say so and skip to Step 3
+
+## Step 3: Propose
+
+After the user answers (or if you skipped Step 2), propose **2-3 approaches**:
+
+```
+**Approach A: [name]**
+- How: [1-2 sentences]
+- Pros: ...
+- Cons: ...
+- Steps:
+  1. [step] — done when: [acceptance criteria]
+  2. [step] — done when: [acceptance criteria]
+
+**Approach B: [name]**
+- How: [1-2 sentences]
+- Pros: ...
+- Cons: ...
+- Steps:
+  1. [step] — done when: [acceptance criteria]
+  2. [step] — done when: [acceptance criteria]
+
+**Recommendation: [A/B/C] because [reason]**
+```
+
+Rules:
+- Approaches must be genuinely different, not trivial variations
+- If there's truly only one reasonable approach, say so — don't invent fake alternatives
+- Include effort estimate for each (small / medium / large)
+- Follow existing codebase patterns unless there's a strong reason not to
+- Flag risks or unknowns you've spotted
+- **Every step must have acceptance criteria** — "done when" must be observable and verifiable, not vague. Bad: "done when refactored". Good: "done when 3 methods extracted, each ≤20 lines, all tests pass"
+
+## Step 4: Self-review
+
+Before presenting to the user, challenge your own proposals:
+
+- Am I overcomplicating this? Is there a simpler way I haven't considered?
+- Am I solving the right problem, or a problem I invented?
+- Does this match existing patterns in the codebase, or am I introducing unnecessary novelty?
+- Did I miss an obvious approach that someone more familiar with this codebase would see?
+- Would I be embarrassed by this proposal after reading more code?
+
+If self-review reveals issues, revise your proposals before presenting. Don't show the user your first draft if you can already see it's flawed.
+
+## Step 5: Wait
+
+**Stop here. Do not proceed until the user picks an approach or gives a green light.**
+
+Do not:
+- Start coding "while waiting"
+- Create files or scaffolding
+- Run exploratory commands beyond what's needed for Step 0-3
+- Say "I'll go ahead and start with Approach A" — that's the user's call
+
+## When this skill ends
+
+When the user confirms an approach, transition to implementation. You now have:
+- Clear scope and boundaries from Step 0-2
+- An agreed approach from Step 3
+- Self-reviewed quality from Step 4
+- Known risks flagged upfront
+
+Carry these forward. If scope changes during implementation, pause and re-align rather than silently expanding.