claude-code-pilot 2.0.0 → 3.0.0

package/src/commands/rust-test.md

@@ -0,0 +1,308 @@
+---
+description: Enforce TDD workflow for Rust. Write tests first, then implement. Verify 80%+ coverage with cargo-llvm-cov.
+---
+
+# Rust TDD Command
+
+This command enforces test-driven development methodology for Rust code using `#[test]`, rstest, proptest, and mockall.
+
+## What This Command Does
+
+1. **Define Types/Traits**: Scaffold function signatures with `todo!()`
+2. **Write Tests**: Create comprehensive test module (RED)
+3. **Run Tests**: Verify tests fail for the right reason
+4. **Implement Code**: Write minimal code to pass (GREEN)
+5. **Refactor**: Improve while keeping tests green
+6. **Check Coverage**: Ensure 80%+ coverage with cargo-llvm-cov
+
+## When to Use
+
+Use `/rust-test` when:
+- Implementing new Rust functions, methods, or traits
+- Adding test coverage to existing Rust code
+- Fixing bugs (write failing test first)
+- Building critical business logic
+- Learning TDD workflow in Rust
+
+## TDD Cycle
+
+```
+RED     -> Write failing test first
+GREEN   -> Implement minimal code to pass
+REFACTOR -> Improve code, tests stay green
+REPEAT  -> Next test case
+```
+
+## Example Session
+
+````text
+User: /rust-test I need a function to validate user registration
+
+Agent:
+# TDD Session: Registration Validator
+
+## Step 1: Define Interface
+
+```rust
+// src/validator.rs
+pub struct RegistrationRequest {
+    pub name: String,
+    pub email: String,
+    pub password: String,
+}
+
+pub enum ValidationResult {
+    Valid,
+    Invalid(Vec<String>),
+}
+
+pub fn validate_registration(request: &RegistrationRequest) -> ValidationResult {
+    todo!()
+}
+```
+
+## Step 2: Write Tests (RED)
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn valid_registration_returns_valid() {
+        let request = RegistrationRequest {
+            name: "Alice".into(),
+            email: "alice@example.com".into(),
+            password: "SecureP@ss1".into(),
+        };
+        assert!(matches!(validate_registration(&request), ValidationResult::Valid));
+    }
+
+    #[test]
+    fn blank_name_returns_invalid() {
+        let request = RegistrationRequest {
+            name: "".into(),
+            email: "alice@example.com".into(),
+            password: "SecureP@ss1".into(),
+        };
+        match validate_registration(&request) {
+            ValidationResult::Invalid(errors) => {
+                assert!(errors.contains(&"Name is required".to_string()));
+            }
+            ValidationResult::Valid => panic!("expected Invalid"),
+        }
+    }
+
+    #[test]
+    fn invalid_email_returns_invalid() {
+        let request = RegistrationRequest {
+            name: "Alice".into(),
+            email: "not-an-email".into(),
+            password: "SecureP@ss1".into(),
+        };
+        assert!(matches!(
+            validate_registration(&request),
+            ValidationResult::Invalid(_)
+        ));
+    }
+
+    #[test]
+    fn short_password_returns_invalid() {
+        let request = RegistrationRequest {
+            name: "Alice".into(),
+            email: "alice@example.com".into(),
+            password: "short".into(),
+        };
+        assert!(matches!(
+            validate_registration(&request),
+            ValidationResult::Invalid(_)
+        ));
+    }
+}
+```
+
+## Step 3: Run Tests — Verify FAIL
+
+```bash
+$ cargo test
+running 4 tests
+test tests::valid_registration_returns_valid ... FAILED (not yet implemented)
+test tests::blank_name_returns_invalid ... FAILED
+test tests::invalid_email_returns_invalid ... FAILED
+test tests::short_password_returns_invalid ... FAILED
+```
+
+Tests fail as expected (todo! panic).
+
+## Step 4: Implement Minimal Code (GREEN)
+
+```rust
+pub fn validate_registration(request: &RegistrationRequest) -> ValidationResult {
+    let mut errors = Vec::new();
+
+    if request.name.trim().is_empty() {
+        errors.push("Name is required".into());
+    }
+    if !request.email.contains('@') {
+        errors.push("Invalid email format".into());
+    }
+    if request.password.len() < 8 {
+        errors.push("Password must be at least 8 characters".into());
+    }
+
+    if errors.is_empty() {
+        ValidationResult::Valid
+    } else {
+        ValidationResult::Invalid(errors)
+    }
+}
+```
+
+## Step 5: Run Tests — Verify PASS
+
+```bash
+$ cargo test
+running 4 tests
+test tests::valid_registration_returns_valid ... ok
+test tests::blank_name_returns_invalid ... ok
+test tests::invalid_email_returns_invalid ... ok
+test tests::short_password_returns_invalid ... ok
+
+test result: ok. 4 passed; 0 failed
+```
+
+All tests passing!
+
+## Step 6: Check Coverage
+
+```bash
+$ cargo llvm-cov
+Coverage: 100.0% of lines
+```
+
+Coverage: 100%
+
+## TDD Complete!
+````
+
+## Test Patterns
+
+### Unit Tests
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn adds_two_numbers() {
+        assert_eq!(add(2, 3), 5);
+    }
+
+    #[test]
+    fn handles_error() -> Result<(), Box<dyn std::error::Error>> {
+        let result = parse_config(r#"port = 8080"#)?;
+        assert_eq!(result.port, 8080);
+        Ok(())
+    }
+}
+```
+
+### Parameterized Tests with rstest
+
+```rust
+use rstest::{rstest, fixture};
+
+#[rstest]
+#[case("hello", 5)]
+#[case("", 0)]
+#[case("rust", 4)]
+fn test_string_length(#[case] input: &str, #[case] expected: usize) {
+    assert_eq!(input.len(), expected);
+}
+```
+
+### Async Tests
+
+```rust
+#[tokio::test]
+async fn fetches_data_successfully() {
+    let client = TestClient::new().await;
+    let result = client.get("/data").await;
+    assert!(result.is_ok());
+}
+```
+
+### Property-Based Tests
+
+```rust
+use proptest::prelude::*;
+
+proptest! {
+    #[test]
+    fn encode_decode_roundtrip(input in ".*") {
+        let encoded = encode(&input);
+        let decoded = decode(&encoded).unwrap();
+        assert_eq!(input, decoded);
+    }
+}
+```
+
+## Coverage Commands
+
+```bash
+# Summary report
+cargo llvm-cov
+
+# HTML report
+cargo llvm-cov --html
+
+# Fail if below threshold
+cargo llvm-cov --fail-under-lines 80
+
+# Run specific test
+cargo test test_name
+
+# Run with output
+cargo test -- --nocapture
+
+# Run without stopping on first failure
+cargo test --no-fail-fast
+```
+
+## Coverage Targets
+
+| Code Type | Target |
+|-----------|--------|
+| Critical business logic | 100% |
+| Public API | 90%+ |
+| General code | 80%+ |
+| Generated / FFI bindings | Exclude |
+
+## TDD Best Practices
+
+**DO:**
+- Write test FIRST, before any implementation
+- Run tests after each change
+- Use `assert_eq!` over `assert!` for better error messages
+- Use `?` in tests that return `Result` for cleaner output
+- Test behavior, not implementation
+- Include edge cases (empty, boundary, error paths)
+
+**DON'T:**
+- Write implementation before tests
+- Skip the RED phase
+- Use `#[should_panic]` when `Result::is_err()` works
+- Use `sleep()` in tests — use channels or `tokio::time::pause()`
+- Mock everything — prefer integration tests when feasible
+
+## Related Commands
+
+- `/rust-build` - Fix build errors
+- `/rust-review` - Review code after implementation
+- `/verify` - Run full verification loop
+
+## Related
+
+- Skill: `skills/rust-testing/`
+- Skill: `skills/rust-patterns/`

package/{ecc → src}/commands/sessions.md

@@ -23,8 +23,8 @@ Display all sessions with metadata, filtering, and pagination.
 **Script:**
 ```bash
 node -e "
-const sm = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const sm = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const result = sm.getAllSessions({ limit: 20 });
 const aliases = aa.listAliases();
@@ -62,8 +62,8 @@ Load and display a session's content (by ID or alias).
 **Script:**
 ```bash
 node -e "
-const sm = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const sm = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 const id = process.argv[1];
 
 // First try to resolve as alias
@@ -123,8 +123,8 @@ Create a memorable alias for a session.
 **Script:**
 ```bash
 node -e "
-const sm = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const sm = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const sessionId = process.argv[1];
 const aliasName = process.argv[2];
@@ -163,7 +163,7 @@ Delete an existing alias.
 **Script:**
 ```bash
 node -e "
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const aliasName = process.argv[1];
 if (!aliasName) {
@@ -192,8 +192,8 @@ Show detailed information about a session.
 **Script:**
 ```bash
 node -e "
-const sm = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const sm = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-manager');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const id = process.argv[1];
 const resolved = aa.resolveAlias(id);
@@ -239,7 +239,7 @@ Show all session aliases.
 **Script:**
 ```bash
 node -e "
-const aa = require((process.env.CLAUDE_PLUGIN_ROOT||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
+const aa = require((process.env.CCP_CLAUDE_DIR||require('path').join(require('os').homedir(),'.claude'))+'/scripts/lib/session-aliases');
 
 const aliases = aa.listAliases();
 console.log('Session Aliases (' + aliases.length + '):');

package/src/commands/setup-pm.md

@@ -0,0 +1,80 @@
+---
+description: Configure your preferred package manager (npm/pnpm/yarn/bun)
+disable-model-invocation: true
+---
+
+# Package Manager Setup
+
+Configure your preferred package manager for this project or globally.
+
+## Usage
+
+```bash
+# Detect current package manager
+node scripts/setup-package-manager.js --detect
+
+# Set global preference
+node scripts/setup-package-manager.js --global pnpm
+
+# Set project preference
+node scripts/setup-package-manager.js --project bun
+
+# List available package managers
+node scripts/setup-package-manager.js --list
+```
+
+## Detection Priority
+
+When determining which package manager to use, the following order is checked:
+
+1. **Environment variable**: `CLAUDE_PACKAGE_MANAGER`
+2. **Project config**: `.claude/package-manager.json`
+3. **package.json**: `packageManager` field
+4. **Lock file**: Presence of package-lock.json, yarn.lock, pnpm-lock.yaml, or bun.lockb
+5. **Global config**: `~/.claude/package-manager.json`
+6. **Fallback**: First available package manager (pnpm > bun > yarn > npm)
+
+## Configuration Files
+
+### Global Configuration
+```json
+// ~/.claude/package-manager.json
+{
+  "packageManager": "pnpm"
+}
+```
+
+### Project Configuration
+```json
+// .claude/package-manager.json
+{
+  "packageManager": "bun"
+}
+```
+
+### package.json
+```json
+{
+  "packageManager": "pnpm@8.6.0"
+}
+```
+
+## Environment Variable
+
+Set `CLAUDE_PACKAGE_MANAGER` to override all other detection methods:
+
+```bash
+# Windows (PowerShell)
+$env:CLAUDE_PACKAGE_MANAGER = "pnpm"
+
+# macOS/Linux
+export CLAUDE_PACKAGE_MANAGER=pnpm
+```
+
+## Run the Detection
+
+To see current package manager detection results, run:
+
+```bash
+node scripts/setup-package-manager.js --detect
+```

package/{kit → src}/commands/setup.md

@@ -13,9 +13,9 @@ Verify that all 4 source directories from the Claude Code Pilot are properly ins
 Check the following paths relative to the project root:
 
 1. **Kit commands** — check if `.claude/commands/setup.md` exists (this file is a kit-specific marker)
-2. **GSD commands** — check if `.claude/commands/gsd/` directory exists and is non-empty (contains the 32 GSD commands)
-3. **ECC toolbox** — check if `.claude/ecc-scripts/` directory exists (contains hooks, lib, detection scripts)
-4. **GSD SDLC workflows** — check if `.claude/get-shit-done/` directory exists and contains `workflows/` subdirectory
+2. **CCP commands** — check if `.claude/commands/ccp/` directory exists and is non-empty (contains the 32 CCP commands)
+3. **CCP toolbox** — check if `.claude/hooks/` directory exists (contains hooks, lib, detection scripts)
+4. **CCP SDLC workflows** — check if `.claude/pilot/` directory exists and contains `workflows/` subdirectory
 
 Use the Bash tool to run existence checks (e.g., `ls` or `test -d`). Count items in each directory.
 
@@ -23,17 +23,17 @@ Present results in this format:
 ```
 Source Directory Detection:
   [PASS] Kit commands     .claude/commands/ (N kit commands)
-  [PASS] GSD commands     .claude/commands/gsd/ (N commands)
-  [PASS] ECC toolbox      .claude/ecc-scripts/ (hooks, lib, detection)
-  [PASS] GSD workflows    .claude/get-shit-done/ (workflows, references, templates)
+  [PASS] CCP commands     .claude/commands/ccp/ (N commands)
+  [PASS] CCP toolbox      .claude/hooks/ (hooks, lib, detection)
+  [PASS] CCP workflows    .claude/pilot/ (workflows, references, templates)
 
 All 4 source directories detected.
 ```
 
 If any directory is missing, show:
 ```
-  [FAIL] GSD commands     .claude/commands/gsd/ -- NOT FOUND
-         Fix: Run /kit:update or reinstall with npx claude-code-pilot@latest
+  [FAIL] CCP commands     .claude/commands/ccp/ -- NOT FOUND
+         Fix: Run /ccp:update or reinstall with npx claude-code-pilot@latest
 ```
 
 Continue to Stage 1 regardless — detection is informational, not blocking.
@@ -53,6 +53,32 @@ Check if this is an existing codebase or new project:
 
 ## Stage 2A — Scan Existing Codebase
 
+### Codebase Intelligence Check
+
+Before subagent exploration, check if codebase-memory-mcp is available for richer codebase analysis:
+
+1. Read `.mcp.json` from project root
+2. Check if `mcpServers["codebase-memory-mcp"]` key exists
+3. If YES: attempt to use the `search_graph` MCP tool to get high-level codebase information:
+   - Call `search_graph` with query: "project structure and main components"
+   - If the call succeeds and returns data: use it to supplement the subagent exploration below (skip redundant grep/find for items already covered by graph results)
+   - If the call fails or returns empty: log a warning and continue with standard exploration
+
+```
+Codebase Intelligence:
+  [ACTIVE]  codebase-memory-mcp detected in .mcp.json — using graph queries for richer analysis
+  -- or --
+  [FALLBACK] codebase-memory-mcp not configured — using file exploration
+  -- or --
+  [FALLBACK] codebase-memory-mcp not responding — falling back to file exploration
+```
+
+4. If NO (key not in .mcp.json): skip graph queries entirely, proceed with standard subagent exploration below.
+
+**Important:** This is a best-effort enhancement. The standard subagent exploration (grep/find) must ALWAYS run as the baseline. Graph results supplement, they don't replace. If codebase-memory-mcp adds value, great. If not, /setup works exactly as before.
+
+---
+
 Use subagents to explore (keeps main context clean). Tailor the exploration prompts based on what Stage 1 detected:
 
 **If Next.js detected** (react + next in dependencies, or next.config.* exists):
@@ -458,8 +484,8 @@ Write CLAUDE.md under 100 lines. Sections:
 - **Build & Validate** (8-10 lines): exact commands
 - **Universal Rules** (5-7 lines): project-specific patterns
 - **Forbidden** (4-6 lines): things that break this project
-- **Methodology — GSD** (6-8 lines): reference /gsd: commands
-- **Toolbox — ECC** (6-8 lines): reference /verify, /checkpoint, /save-session, /learn
+- **Methodology — CCP** (6-8 lines): reference /ccp: commands
+- **Toolbox — CCP** (6-8 lines): reference /verify, /checkpoint, /save-session, /learn
 - **Before ANY work** (2 lines): `npx skills find <keywords>`
 - **Reference Docs & MCP** (3-4 lines): point to docs/, contexts/, registries
 - **Gotchas** (3-5 lines): non-obvious things from scan
@@ -537,8 +563,8 @@ Check MCP registries (github.com/mcp, mcp.so) for relevant servers.
 
 ## Stage 9 — Initialize
 
-- **New project**: Suggest `/gsd:new-project` for roadmap/milestones
-- **Existing project**: Suggest `/gsd:quick "first task"` or `/gsd:discuss-phase 1`
+- **New project**: Suggest `/ccp:new-project` for roadmap/milestones
+- **Existing project**: Suggest `/ccp:quick "first task"` or `/ccp:discuss-phase 1`
 
 ---
 
@@ -548,8 +574,8 @@ Check MCP registries (github.com/mcp, mcp.so) for relevant servers.
 git add CLAUDE.md */CLAUDE.md .claude/ .mcp.json docs/
 git commit -m "chore: add Claude Code Pilot
 
-- GSD methodology (32 commands, 12 agents)
-- ECC toolbox (sessions, learning, verification, quality gates)
+- CCP methodology (32 commands, 12 agents)
+- CCP toolbox (sessions, learning, verification, quality gates)
 - Language rules: [detected]
 - Directory-scoped CLAUDE.md files: [list of directories]
 - MCP auto-configured: [list of detected tools]
@@ -564,16 +590,16 @@ Setup complete!
 Configured:
 - CLAUDE.md — [X]-line project guide
 - [N] directory CLAUDE.md files (src/, test/, ...)
-- GSD — 32 commands, 12 agents, context monitoring, statusline
-- ECC — Sessions, learning, verification, checkpoints, quality gates
-- [N] ECC agents (architect, code-reviewer, security, tdd, ...)
+- CCP — 32 commands, 12 agents, context monitoring, statusline
+- CCP — Sessions, learning, verification, checkpoints, quality gates
+- [N] CCP agents (architect, code-reviewer, security, tdd, ...)
 - [N] language rule sets activated
 - [N] ecosystem skills installed
 - MCP tools: [list of detected/added tools]
 - Safety hooks + desktop notifications
 
-Methodology:  /gsd:discuss → /gsd:plan → /gsd:execute → /gsd:verify
+Methodology:  /ccp:discuss → /ccp:plan → /ccp:execute → /ccp:verify
 Quality:      /verify → /checkpoint → /quality-gate
 Persistence:  /save-session → /resume-session → /learn → /evolve
-Update:       /kit:update
+Update:       /ccp:update
 ```