5-phase-workflow 1.0.0

package/src/commands/5/verify-implementation.md

@@ -0,0 +1,277 @@
+---
+name: 5:verify-implementation
+description: Verifies completed feature implementation by delegating checks to verification-agent. Runs in forked context to minimize main context usage.
+allowed-tools: Read, Glob, Write, AskUserQuestion, Bash, Task, mcp__jetbrains__*
+context: fork
+user-invocable: true
+---
+
+# Verify Implementation (Phase 4)
+
+## Overview
+
+This skill provides comprehensive verification of a completed feature implementation. It is typically invoked:
+1. Automatically by `/implement-feature` at the end of Wave 7
+2. Manually by the developer to verify a feature
+3. After fixing issues to re-verify
+
+**Architecture:** `Command -> Agent -> Tools`
+- This command runs in forked context to minimize main context usage
+- Delegates verification work to the verification-agent (also forked context)
+- Handles reporting, state updates, and user interaction within the forked context
+
+## Verification Process
+
+### Step 1: Load Implementation Plan
+
+Read the implementation plan from `.5/{feature-name}/plan.md` where `{feature-name}` is the argument provided by the user.
+
+**Error Handling:** If the plan file is missing or unreadable:
+- Return fail status immediately
+- Display clear error message: "Error: Implementation plan not found at `.5/{feature-name}/plan.md`. Please run /plan-implementation first."
+- Do not proceed to Step 2
+
+Extract:
+- Component checklist (all expected files)
+- Affected modules
+- Test modules
+
+### Step 2: Spawn verification-agent
+
+Read `.claude/agents/verification-agent.md` for agent instructions, then spawn via Task tool:
+
+```
+Task tool call:
+  subagent_type: general-purpose
+  description: "Verify {feature-name}"
+  prompt: |
+    {Contents of verification-agent.md}
+
+    ---
+
+    ## Your Task
+
+    Feature Name: {feature-name}
+    Implementation Plan Path: .5/{feature-name}/plan.md
+    Expected Files:
+    - {path/to/file1.ext}
+    - {path/to/file2.ext}
+    Affected Modules:
+    - {module-path-1}
+    - {module-path-2}
+    Test Modules:
+    - {module-path-for-tests}
+```
+
+### Step 3: Process Agent Results
+
+Receive the structured results from verification-agent:
+- Overall status (passed/passed-with-warnings/failed)
+- Implementation completeness results (tasks, method signatures, test coverage, acceptance criteria)
+- File existence results
+- Problem detection results (errors vs warnings)
+- Compilation results
+- Test results
+- Generated verification report (Markdown)
+
+### Step 4: Save Verification Report
+
+Write the verification report from the agent to:
+`.5/{feature-name}/verification.md`
+
+### Step 5: Update State File
+
+Update `.5/{feature-name}/state.json` with verification results:
+
+```json
+{
+  "verificationResults": {
+    "status": "passed | passed-with-warnings | failed",
+    "timestamp": "{ISO timestamp}",
+    "implementationCompleteness": {
+      "tasksTotal": N,
+      "tasksCompleted": N,
+      "tasksPartial": N,
+      "tasksMissing": N
+    },
+    "filesChecked": N,
+    "filesExist": N,
+    "compilationStatus": "success | failed",
+    "testStatus": "passed | failed",
+    "testsTotal": N,
+    "testsPassed": N,
+    "testsFailed": N,
+    "errorsFound": N,
+    "warningsFound": N,
+    "reportPath": ".5/{feature-name}/verification.md"
+  }
+}
+```
+
+If status is "passed" or "passed-with-warnings", also update:
+```json
+{
+  "status": "completed",
+  "completedAt": "{ISO timestamp}"
+}
+```
+
+### Step 6: Inform Developer
+
+**If PASSED:**
+```
+Verification PASSED!
+
+All checks completed successfully:
+- Implementation: {N}/{N} tasks completed
+- Files: {N}/{N} exist
+- Compilation: Success
+- Tests: All passing ({N} tests)
+- Errors: 0
+- Warnings: {N}
+
+Verification report: .5/{feature-name}/verification.md
+
+Ready to commit and create pull request!
+```
+
+**If PASSED WITH WARNINGS:**
+```
+Verification PASSED with warnings
+
+All critical checks passed, but warnings were found:
+- Implementation: {N}/{N} tasks completed ({N} partial or minor deviations)
+- Files: {N}/{N} exist
+- Compilation: Success
+- Tests: All passing ({N} tests)
+- Errors: 0
+- Warnings: {N}
+
+See warnings in verification report:
+.5/{feature-name}/verification.md
+
+You may address warnings before committing, but they don't block completion.
+
+Ready to commit!
+```
+
+**If FAILED:**
+```
+Verification FAILED
+
+Issues found:
+- Implementation: {N}/{N} tasks incomplete
+- Files missing: {N}
+- Compilation: Failed
+- Tests: {N} failures
+- Errors: {N}
+
+See detailed errors in verification report:
+.5/{feature-name}/verification.md
+
+Please fix the errors and complete missing tasks, then re-run /verify-implementation {feature-name}
+```
+
+### Step 7: Prompt for Commit
+
+**Only if verification PASSED or PASSED WITH WARNINGS**, use AskUserQuestion to ask if the user wants to commit the changes:
+
+**Question:**
+```
+Would you like to commit these changes now?
+
+It's recommended to commit changes before running CodeRabbit review (/review-code).
+```
+
+**Options:**
+1. "Yes - Create commit now (Recommended)"
+2. "No - I'll commit manually later"
+
+**If user selects "Yes":**
+- Create commit using the standard commit message format below
+- Stage all relevant files
+- Create commit with proper message format
+
+**If user selects "No":**
+- Tell user: "You can commit the changes manually when ready. After committing, run `/review-code` for CodeRabbit review."
+
+#### Commit Message Format
+
+**CRITICAL:** Follow this exact format when creating commits:
+
+```
+{TICKET-ID} Short description of what is done (~50 chars)
+
+- What changed and why (important points only)
+- Another change and reason
+- Keep it concise, no verbose descriptions
+- No emojis
+```
+
+**Guidelines:**
+- First line: `{TICKET-ID}` + space + short description (~50 characters max)
+- Blank line after first line
+- Bullet points for changes (what changed and why)
+- Only important points, no verbose descriptions
+- No emojis
+- No AI attribution or Co-Authored-By lines
+
+**Implementation:**
+When creating the commit, use HEREDOC format:
+
+```bash
+git add [relevant files]
+git commit -m "$(cat <<'EOF'
+PROJ-1234 Short description here
+
+- Change 1 and reason
+- Change 2 and reason
+EOF
+)"
+```
+
+## Instructions Summary
+
+1. **Load implementation plan** from `.5/{feature-name}/plan.md`
+2. **Spawn verification-agent** with expected files, modules, and test modules
+3. **Process agent results** - extract status, report, and structured data
+4. **Save verification report** to state directory
+5. **Update state file** with verification results
+6. **Inform developer** with clear status
+7. **Prompt for commit** (if PASSED or PASSED WITH WARNINGS) - Recommended before CodeRabbit review
+
+## Key Principles
+
+1. **Thin orchestrator** - Delegate verification work to agent, keep interactive parts in main context
+2. **Comprehensive** - Agent checks everything (files, problems, compilation, tests)
+3. **Categorized** - Separate errors (block) from warnings (report)
+4. **Actionable** - Clear report of what needs fixing
+5. **Persistent** - Save report for reference
+6. **Resumable** - Can be re-run after fixes
+7. **Commit ready** - Prompt for commit after successful verification
+
+## DO NOT
+
+- DO NOT run compilation or tests directly (agent handles this)
+- DO NOT run problem detection directly (agent handles this)
+- DO NOT block on warnings (only errors block)
+- DO NOT skip state file update
+- DO NOT skip saving verification report
+- DO NOT skip asking about commit if verification passed
+- DO NOT automatically create commits without user approval
+- DO NOT use emojis in commit messages
+- DO NOT include AI attribution or Co-Authored-By lines in commit messages
+
+## Error Handling
+
+If the verification-agent fails to return results:
+1. Record the failure in the state file
+2. Mark overall verification as FAILED
+3. Include diagnostic information in report
+4. Suggest re-running verification
+
+## Related Documentation
+
+- [Agent: verification-agent](../agents/verification-agent.md)
+- [/implement-feature command](implement-feature.md)
+- [/plan-implementation command](plan-implementation.md)

package/src/hooks/statusline.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+// Claude Code Statusline
+// Shows: model | directory | context usage
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Read JSON from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const model = data.model?.display_name || 'Claude';
+    const dir = data.workspace?.current_dir || process.cwd();
+    const session = data.session_id || '';
+    const remaining = data.context_window?.remaining_percentage;
+
+    // Context window display (shows USED percentage)
+    let ctx = '';
+    if (remaining != null) {
+      const rem = Math.round(remaining);
+      const used = Math.max(0, Math.min(100, 100 - rem));
+
+      // Build progress bar (10 segments)
+      const filled = Math.floor(used / 10);
+      const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+
+      // Color based on usage
+      if (used < 50) {
+        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+      } else if (used < 65) {
+        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+      } else if (used < 80) {
+        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+      } else {
+        ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
+      }
+    }
+
+    // Shorten directory path for display
+    const shortDir = dir.replace(os.homedir(), '~');
+
+    // Build and output statusline: model | directory | context
+    const statusline = `\x1b[36m${model}\x1b[0m | \x1b[90m${shortDir}\x1b[0m${ctx}`;
+    process.stdout.write(statusline);
+
+  } catch (e) {
+    // Silent fail - don't break statusline on parse errors
+  }
+});

package/src/settings.json

@@ -0,0 +1,6 @@
+{
+  "statusLine": {
+    "type": "command",
+    "command": "node .claude/hooks/statusline.js"
+  }
+}

package/src/skills/build-project/SKILL.md

@@ -0,0 +1,277 @@
+---
+name: build-project
+description: Builds the project using auto-detected or configured build system. Supports npm, gradle, cargo, go, maven, make, and more. Use when compiling, building, or verifying project build status.
+allowed-tools: Bash, Read, Grep
+model: sonnet
+context: fork
+user-invocable: true
+---
+
+# Build Project
+
+## Overview
+
+This skill executes build tasks with auto-detection of the build system and sufficient timeout for long-running builds. It provides structured error reporting and actionable suggestions when builds fail.
+
+## Build System Detection
+
+The skill automatically detects the build system using:
+
+1. **Config file** (`.claude/.5/config.json`) - if `build.command` is specified
+2. **Auto-detection** - by examining project files:
+   - `package.json` → npm/yarn/pnpm
+   - `build.gradle` or `build.gradle.kts` → Gradle
+   - `pom.xml` → Maven
+   - `Cargo.toml` → Cargo (Rust)
+   - `go.mod` → Go
+   - `Makefile` → Make
+   - `setup.py` or `pyproject.toml` → Python
+
+## Build Targets
+
+| Target | Use Case |
+|--------|----------|
+| `compile` | Fast compilation check (no tests, no packaging) |
+| `build` | Full build (may include tests depending on tool) |
+| `clean` | Clean build (removes previous artifacts first) |
+
+## Parameters
+
+When invoked, the skill expects:
+
+- **target** (optional, default: `build`): One of `compile`, `build`, `clean`
+- **module** (optional): Specific module to build (for monorepos)
+
+## Execution Process
+
+### 1. Load Configuration
+
+Read `.claude/.5/config.json` if it exists:
+
+```json
+{
+  "build": {
+    "command": "npm run build",
+    "compileCommand": "npm run compile",
+    "cleanCommand": "npm run clean"
+  }
+}
+```
+
+If commands are specified, use them. Otherwise, auto-detect.
+
+### 2. Detect Build System
+
+If no config, examine project files to detect build system:
+
+```bash
+# Check for package.json
+if [ -f "package.json" ]; then
+  # Check for lock files to determine package manager
+  if [ -f "pnpm-lock.yaml" ]; then
+    BUILD_TOOL="pnpm"
+  elif [ -f "yarn.lock" ]; then
+    BUILD_TOOL="yarn"
+  else
+    BUILD_TOOL="npm"
+  fi
+fi
+
+# Check for Gradle
+if [ -f "build.gradle" ] || [ -f "build.gradle.kts" ]; then
+  BUILD_TOOL="gradle"
+fi
+
+# Check for Maven
+if [ -f "pom.xml" ]; then
+  BUILD_TOOL="mvn"
+fi
+
+# Check for Cargo
+if [ -f "Cargo.toml" ]; then
+  BUILD_TOOL="cargo"
+fi
+
+# Check for Go
+if [ -f "go.mod" ]; then
+  BUILD_TOOL="go"
+fi
+
+# Check for Make
+if [ -f "Makefile" ]; then
+  BUILD_TOOL="make"
+fi
+```
+
+### 3. Determine Build Command
+
+Based on detected tool and target:
+
+| Tool | compile | build | clean |
+|------|---------|-------|-------|
+| npm | `npm run build` | `npm run build` | `rm -rf dist node_modules && npm install` |
+| yarn | `yarn build` | `yarn build` | `yarn clean` or `rm -rf dist` |
+| pnpm | `pnpm build` | `pnpm build` | `pnpm clean` or `rm -rf dist` |
+| gradle | `./gradlew compileJava -x test --offline` | `./gradlew build -x test --offline` | `./gradlew clean build` |
+| mvn | `mvn compile` | `mvn package -DskipTests` | `mvn clean package` |
+| cargo | `cargo check` | `cargo build` | `cargo clean && cargo build` |
+| go | `go build ./...` | `go build ./...` | `go clean && go build ./...` |
+| make | `make` | `make` | `make clean` |
+
+### 4. Execute Build with Proper Timeout
+
+**IMPORTANT**: Builds can take several minutes. Use generous timeout:
+
+```bash
+# Timeout based on target
+# - compile: 2 minutes (120000ms)
+# - build: 10 minutes (600000ms)
+# - clean: 15 minutes (900000ms)
+```
+
+Execute the command and capture output.
+
+### 5. Parse Build Output
+
+Analyze output to identify:
+
+#### Success Indicators
+
+Tool-specific success patterns:
+- npm/yarn/pnpm: No error messages, process exits with 0
+- Gradle: `BUILD SUCCESSFUL`
+- Maven: `BUILD SUCCESS`
+- Cargo: `Finished` or `Compiling`
+- Go: No error output
+- Make: No error messages
+
+#### Error Types
+
+**Compilation Errors**:
+```
+/path/to/file.ext:42: error: ...
+```
+Extract: file path, line number, error message
+
+**Dependency Issues**:
+```
+Could not resolve dependencies
+Module not found
+```
+Suggest: `npm install`, `./gradlew --refresh-dependencies`, etc.
+
+**Out of Memory**:
+```
+JavaScript heap out of memory
+Java heap space
+```
+Suggest: Increase memory allocation
+
+**Tool Not Found**:
+```
+command not found: npm
+```
+Suggest: Install the build tool
+
+### 6. Format Output
+
+Provide structured response:
+
+```
+BUILD STATUS: ✓ SUCCESS | ✗ FAILED
+DURATION: 2m 34s
+TOOL: {detected-tool}
+TARGET: {target}
+MODULE: {module or "all"}
+
+SUMMARY:
+- Build completed successfully
+OR
+- Build failed with X errors
+
+ERRORS: (if any)
+File: path/to/file.ext:42
+Error: {error message}
+
+File: path/to/another.ext:15
+Error: {error message}
+
+SUGGESTIONS:
+- {actionable suggestion based on error type}
+```
+
+## Common Build Scenarios
+
+### First-Time Build
+
+May fail with dependency issues. Suggestions:
+- npm: `npm install`
+- gradle: Remove `--offline` flag temporarily
+- cargo: `cargo fetch`
+
+### Incremental Build Issues
+
+Stale cache or artifacts. Suggestions:
+- Try `clean` target
+- Clear cache manually
+
+### Memory Issues
+
+Build runs out of memory. Suggestions:
+- npm: `export NODE_OPTIONS="--max-old-space-size=4096"`
+- gradle: Add `org.gradle.jvmargs=-Xmx4g` to `gradle.properties`
+- maven: `export MAVEN_OPTS="-Xmx4g"`
+
+## Error Handling
+
+- If build tool cannot be detected, return error with list of checked locations
+- If command times out, report timeout with suggestion to increase timeout or optimize build
+- If build fails, extract and format all errors for user
+- Always include the raw command that was executed for reproducibility
+
+## DO NOT
+
+- DO NOT modify source files
+- DO NOT install dependencies (unless explicitly part of clean target)
+- DO NOT run tests (use `/run-tests` skill for that)
+- DO NOT assume a specific build system - always detect or use config
+- DO NOT use overly short timeouts (builds can be slow)
+
+## Examples
+
+### Example 1: Auto-detect npm and build
+
+```
+User: /build-project
+
+Skill: [Detects package.json, uses npm]
+Skill: [Runs: npm run build]
+Skill: [Reports success with duration]
+```
+
+### Example 2: Gradle with module
+
+```
+User: /build-project module=user-service
+
+Skill: [Detects build.gradle]
+Skill: [Runs: ./gradlew :user-service:build -x test --offline]
+Skill: [Reports success]
+```
+
+### Example 3: Build failure
+
+```
+User: /build-project
+
+Skill: [Detects Cargo.toml]
+Skill: [Runs: cargo build]
+Skill: [Detects compilation error]
+Skill: [Reports: File src/main.rs:42, Error: mismatched types]
+Skill: [Suggests: Fix type error in src/main.rs:42]
+```
+
+## Related Documentation
+
+- [5-Phase Workflow Guide](../../docs/workflow-guide.md)
+- [/run-tests skill](../run-tests/SKILL.md)