Initial commit

.claude/commands/code.md

@@ -0,0 +1,666 @@
+---
+description: Implement feature from flexible input (story file, task ID, brief, or issue)
+argument-hint: "<input>"
+allowed-tools: Read, Write, Edit, Bash, Task, Glob, Grep
+---
+
+# Code Command: Flexible Feature Implementation
+
+Transform any input into working code with intelligent orchestration.
+
+## Core Philosophy
+
+**Accept anything, infer everything, build intelligently.**
+
+No flags, no ceremony - just provide context and get code.
+
+## Usage Examples
+
+```bash
+# Quick feature from brief
+/lazy code "add logout button to header"
+
+# From user story file
+/lazy code @US-3.4.md
+/lazy code US-3.4.md
+
+# From task ID (auto-finds story)
+/lazy code TASK-003
+
+# From GitHub issue
+/lazy code #456
+/lazy code 456
+```
+
+## Input Detection Logic
+
+### Phase 0: Parse Input
+
+**Detect input type:**
+
+```python
+input = "$ARGUMENTS".strip()
+
+if input.startswith("@") or input.endswith(".md"):
+    # User story file reference
+    input_type = "story_file"
+    story_file = input.lstrip("@")
+
+elif input.startswith("TASK-") or input.startswith("task-"):
+    # Task ID - need to find story
+    input_type = "task_id"
+    task_id = input.upper()
+
+elif input.startswith("#") or input.isdigit():
+    # GitHub issue
+    input_type = "github_issue"
+    issue_number = input.lstrip("#")
+
+else:
+    # Brief description
+    input_type = "brief"
+    feature_brief = input
+```
+
+### Phase 1: Load Context
+
+**From User Story File:**
+```bash
+# If input is @US-3.4.md or US-3.4.md
+story_path="./project-management/US-STORY/*/US-story.md"
+story_path=$(find ./project-management/US-STORY -name "*${story_id}*" -type d -exec find {} -name "US-story.md" \; | head -1)
+
+# Read full story content
+story_content=$(cat "$story_path")
+
+# Find next pending task or use all tasks
+next_task=$(grep -E "^### TASK-[0-9]+" "$story_path" | head -1)
+```
+
+**From Task ID:**
+```bash
+# If input is TASK-003
+# Find which story contains this task
+story_path=$(grep -r "### ${task_id}:" ./project-management/US-STORY --include="US-story.md" -l | head -1)
+
+# Extract story content
+story_content=$(cat "$story_path")
+
+# Extract specific task section
+task_section=$(sed -n "/^### ${task_id}:/,/^### TASK-/p" "$story_path" | sed '$d')
+```
+
+**From GitHub Issue:**
+```bash
+# If input is #456 or 456
+issue_content=$(gh issue view ${issue_number} --json title,body,labels --jq '{title, body, labels: [.labels[].name]}')
+
+# Parse as story or task
+# If issue has "user-story" label, treat as story
+# Otherwise treat as single task
+```
+
+**From Brief Description:**
+```bash
+# If input is "add logout button to header"
+# Create minimal context
+feature_brief="$input"
+
+# Generate inline task
+task_section="
+### TASK-1: ${feature_brief}
+
+**Description:**
+${feature_brief}
+
+**Acceptance Criteria:**
+- Implementation works as described
+- Code follows project conventions
+- Basic error handling included
+"
+```
+
+## Smart Orchestration Logic
+
+### Auto-Detection Rules
+
+**1. Test Detection:**
+```python
+# Check if project uses tests
+has_tests = any([
+    exists("pytest.ini"),
+    exists("tests/"),
+    exists("__tests__/"),
+    exists("*.test.js"),
+    exists("*_test.py"),
+])
+
+# Check if TDD mentioned in docs
+tdd_required = any([
+    "TDD" in read("README.md"),
+    "test-driven" in read("CLAUDE.md"),
+    "LAZYDEV_ENFORCE_TDD" in env,
+])
+
+# Decision
+run_tests = has_tests or tdd_required or "test" in task_section.lower()
+```
+
+**2. Complexity Detection:**
+```python
+# Analyze task complexity
+complexity_indicators = [
+    "security", "authentication", "auth", "payment",
+    "database", "migration", "critical", "api",
+]
+
+# Check task content
+is_complex = any(keyword in task_section.lower() for keyword in complexity_indicators)
+
+# Check estimate
+if "Estimate:" in task_section:
+    estimate = extract_estimate(task_section)
+    is_complex = is_complex or estimate in ["L", "Large"]
+
+# Default to simple
+complexity = "complex" if is_complex else "simple"
+```
+
+**3. Review Detection:**
+```python
+# Always review complex tasks
+needs_review = is_complex
+
+# Review if multi-file changes expected
+if not needs_review:
+    # Check if task mentions multiple files/modules
+    multi_file_keywords = [
+        "refactor", "restructure", "multiple files",
+        "across", "integration", "system-wide"
+    ]
+    needs_review = any(kw in task_section.lower() for kw in multi_file_keywords)
+
+# Can skip for simple single-file changes
+skip_review = not needs_review and complexity == "simple"
+```
+
+**4. User Story Detection:**
+```python
+# Check if we have a full story or single task
+if input_type == "story_file":
+    has_story = True
+    # Work through tasks sequentially
+
+elif input_type == "task_id":
+    has_story = True
+    # Story was found, implement specific task
+
+elif input_type == "github_issue":
+    # Check if issue is tagged as story
+    has_story = "user-story" in issue_labels
+
+else:  # brief
+    has_story = False
+    # Single task, quick implementation
+```
+
+## Execution Workflow
+
+### Phase 2: Git Branch Setup
+
+```bash
+# Only create branch if working from story
+if [ "$has_story" = true ]; then
+    # Extract story ID from path or content
+    story_id=$(extract_story_id)
+    branch_name="feat/${story_id}-$(slugify_story_title)"
+
+    # Create or checkout branch
+    if git show-ref --verify --quiet "refs/heads/$branch_name"; then
+        git checkout "$branch_name"
+    else
+        git checkout -b "$branch_name"
+    fi
+else
+    # Work on current branch for quick tasks
+    current_branch=$(git branch --show-current)
+    echo "Working on current branch: $current_branch"
+fi
+```
+
+### Phase 3: Implementation
+
+**Delegate to coder agent:**
+
+```python
+Task(
+    prompt=f"""
+You are the Coder Agent for LAZY-DEV-FRAMEWORK.
+
+## Context Provided
+
+{story_content if has_story else ""}
+
+## Task to Implement
+
+{task_section}
+
+## Implementation Guidelines
+
+1. **Read existing code first:**
+   - Check README.md for project structure and conventions
+   - Look for similar implementations in codebase
+   - Identify existing patterns and styles
+
+2. **Write clean, maintainable code:**
+   - Type hints on all functions (if Python/TypeScript)
+   - Docstrings for public APIs
+   - Clear variable names
+   - Error handling with specific exceptions
+
+3. **Follow project conventions:**
+   - Check for .editorconfig, .prettierrc, pyproject.toml
+   - Match existing code style
+   - Use project's logging/error patterns
+
+4. **Tests (if required):**
+   - TDD required: {run_tests}
+   - Write tests if TDD enabled or "test" mentioned in task
+   - Follow existing test patterns in repo
+   - Aim for edge case coverage
+
+5. **Security considerations:**
+   - Input validation
+   - No hardcoded secrets
+   - Proper error messages (no sensitive data leaks)
+   - Follow OWASP guidelines for web/API code
+
+## Quality Standards
+
+Code will be automatically checked by PostToolUse hook:
+- Formatting (Black/Ruff/Prettier if configured)
+- Linting (Ruff/ESLint if configured)
+- Type checking (Mypy/TSC if configured)
+- Tests (Pytest/Jest if TDD enabled)
+
+Write quality code to pass these checks on first run.
+
+## Output
+
+Provide:
+1. Implementation files (with full paths)
+2. Test files (if TDD enabled)
+3. Updated documentation (if API changes)
+4. Brief summary of changes
+
+DO NOT create a commit - that happens after review.
+"""
+)
+```
+
+### Phase 4: Quality Checks (Automatic)
+
+**PostToolUse hook handles this automatically after Write/Edit operations:**
+
+- Format: Auto-applied (Black/Ruff/Prettier)
+- Lint: Auto-checked, warns if issues
+- Type: Auto-checked, warns if issues
+- Tests: Auto-run if TDD required
+
+**No manual action needed** - hook runs after coder agent completes.
+
+### Phase 5: Code Review (Conditional)
+
+**Review decision:**
+
+```python
+if needs_review:
+    # Invoke reviewer agent for complex/critical tasks
+    Task(
+        prompt=f"""
+You are the Reviewer Agent for LAZY-DEV-FRAMEWORK.
+
+## Task Being Reviewed
+
+{task_section}
+
+## Changes Made
+
+{git_diff_output}
+
+## Review Checklist
+
+**Code Quality:**
+- Readability and maintainability
+- Follows project conventions
+- Appropriate abstractions
+- Clear naming
+
+**Correctness:**
+- Meets acceptance criteria
+- Edge cases handled
+- Error handling appropriate
+
+**Security (if applicable):**
+- Input validation
+- No hardcoded secrets
+- Proper authentication/authorization
+- No SQL injection / XSS vulnerabilities
+
+**Tests (if TDD required):**
+- Tests cover main functionality
+- Edge cases tested
+- Tests are clear and maintainable
+
+## Output
+
+Return ONE of:
+- **APPROVED**: Changes look good, ready to commit
+- **REQUEST_CHANGES**: List specific issues to fix
+
+Keep feedback concise and actionable.
+"""
+    )
+else:
+    echo "Review skipped: Simple task, single-file change"
+fi
+```
+
+### Phase 6: Commit
+
+**Only commit if approved or review skipped:**
+
+```bash
+# Prepare commit message
+if [ "$has_story" = true ]; then
+    commit_msg="feat(${task_id}): $(extract_task_title)
+
+Implements ${task_id} from ${story_id}
+
+$(summarize_changes)
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+Co-Authored-By: Claude <noreply@anthropic.com>"
+else
+    commit_msg="feat: ${feature_brief}
+
+Quick implementation from brief description.
+
+$(summarize_changes)
+
+🤖 Generated with [Claude Code](https://claude.com/claude-code)
+
+Co-Authored-By: Claude <noreply@anthropic.com>"
+fi
+
+# Create commit
+git add .
+
+git commit -m "$(cat <<'EOF'
+$commit_msg
+EOF
+)"
+
+# Tag if task completion
+if [ "$input_type" = "task_id" ]; then
+    git tag "task/${task_id}-done"
+fi
+```
+
+### Phase 7: Output Summary
+
+```
+Task Complete
+=============
+Input: {input}
+Type: {input_type}
+{Story: {story_id}}
+{Task: {task_id}}
+Branch: {branch_name}
+Complexity: {complexity}
+Review: {skipped|passed}
+Tests: {passed|skipped} {(n/n)}
+Commit: {commit_hash}
+
+Files Changed:
+- {file1}
+- {file2}
+
+Next Steps:
+{- Continue with next task: /lazy code TASK-{next}}
+{- Review story and create PR: /lazy review {story_id}}
+{- Work on new feature: /lazy code "description"}
+```
+
+## Intelligence Matrix
+
+| Input | Detection | Story Lookup | Tests | Review | Branch |
+|-------|-----------|--------------|-------|--------|--------|
+| "brief" | Brief text | No | Auto | Simple=No | Current |
+| @US-3.4.md | File reference | Yes (read file) | Auto | Smart | feat/US-3.4-* |
+| TASK-003 | Task ID pattern | Yes (grep) | Auto | Smart | feat/US-* |
+| #456 | Issue number | Yes (gh) | Auto | Smart | feat/issue-456 |
+
+**Auto = Check project for test framework and TDD requirement**
+**Smart = Complex/multi-file/security = Yes, Simple/single-file = No**
+
+## Decision Trees
+
+### Test Execution Decision
+
+```
+Has test framework in repo? ────No───→ Skip tests
+         │
+        Yes
+         │
+TDD in docs or LAZYDEV_ENFORCE_TDD? ──Yes──→ Run tests (required)
+         │
+         No
+         │
+"test" mentioned in task? ────Yes───→ Run tests (requested)
+         │
+         No
+         │
+      Skip tests
+```
+
+### Review Decision
+
+```
+Task complexity = complex? ───Yes───→ Review required
+         │
+         No
+         │
+Security/auth/payment related? ──Yes──→ Review required
+         │
+         No
+         │
+Multi-file refactor? ────Yes────→ Review required
+         │
+         No
+         │
+      Skip review (simple task)
+```
+
+### Branch Strategy
+
+```
+Input has story context? ───Yes───→ Create/use feat/{story-id}-* branch
+         │
+         No
+         │
+   Work on current branch
+```
+
+## Examples in Action
+
+### Example 1: Quick Feature
+```bash
+$ /lazy code "add logout button to header"
+
+Detected: Brief description
+Complexity: Simple (single feature)
+Tests: Auto-detected (pytest found in repo)
+Review: Skipped (simple, single-file)
+Branch: Current branch
+
+Implementing...
+✓ Added logout button to src/components/Header.tsx
+✓ Added test in tests/components/Header.test.tsx
+✓ Quality checks passed
+✓ Committed: feat: add logout button to header
+
+Complete! (1 file changed)
+```
+
+### Example 2: From Story File
+```bash
+$ /lazy code @US-3.4.md
+
+Detected: User story file
+Story: US-3.4 - OAuth2 Authentication
+Next pending: TASK-002 - Implement token refresh
+Complexity: Complex (auth + security)
+Tests: Required (TDD in CLAUDE.md)
+Review: Required (complex task)
+Branch: feat/US-3.4-oauth2-authentication
+
+Implementing...
+✓ Implemented token refresh in src/auth/refresh.py
+✓ Added tests in tests/auth/test_refresh.py
+✓ Quality checks passed
+✓ Code review: APPROVED
+✓ Committed: feat(TASK-002): implement token refresh
+
+Complete! Continue with: /lazy code TASK-003
+```
+
+### Example 3: From Task ID
+```bash
+$ /lazy code TASK-007
+
+Detected: Task ID
+Finding story... Found in US-2.1-payment-processing
+Task: TASK-007 - Add retry logic to payment API
+Complexity: Complex (payment + API)
+Tests: Required (pytest found)
+Review: Required (payment-related)
+Branch: feat/US-2.1-payment-processing
+
+Implementing...
+✓ Added retry logic to src/payment/api.py
+✓ Added retry tests in tests/payment/test_api.py
+✓ Quality checks passed
+✓ Code review: APPROVED
+✓ Committed: feat(TASK-007): add retry logic to payment API
+✓ Tagged: task/TASK-007-done
+
+Complete! Continue with: /lazy code TASK-008
+```
+
+### Example 4: From GitHub Issue
+```bash
+$ /lazy code #456
+
+Detected: GitHub issue
+Fetching issue #456...
+Issue: "Fix validation error in user signup form"
+Labels: bug, frontend
+Complexity: Simple (bug fix)
+Tests: Required (jest found in repo)
+Review: Skipped (simple bug fix)
+Branch: Current branch
+
+Implementing...
+✓ Fixed validation in src/components/SignupForm.tsx
+✓ Added regression test in tests/components/SignupForm.test.tsx
+✓ Quality checks passed
+✓ Committed: fix: validation error in user signup form (closes #456)
+
+Complete! Issue #456 will be closed on PR merge.
+```
+
+## Key Principles
+
+1. **Zero Configuration**: No flags, no setup - just provide input
+2. **Smart Defaults**: Infer tests, review, complexity from context
+3. **Flexible Input**: Accept stories, tasks, briefs, issues
+4. **Auto Quality**: PostToolUse hook handles formatting/linting/tests
+5. **Contextual Branching**: Stories get branches, briefs work on current
+6. **Progressive Enhancement**: More context = smarter orchestration
+
+## Integration Points
+
+**With plan command:**
+```bash
+/lazy plan "feature description"  # Creates US-story.md
+/lazy code @US-story.md          # Implements first task
+/lazy code TASK-002              # Continues with next task
+```
+
+**With review command:**
+```bash
+/lazy code TASK-001  # Commit 1
+/lazy code TASK-002  # Commit 2
+/lazy code TASK-003  # Commit 3
+/lazy review US-3.4  # Review all tasks, create PR
+```
+
+**With fix command:**
+```bash
+/lazy code TASK-001       # Implementation
+/lazy review US-3.4       # Generates review-report.md
+/lazy fix review-report.md  # Apply fixes
+```
+
+## Environment Variables
+
+```bash
+# Force TDD for all tasks
+export LAZYDEV_ENFORCE_TDD=1
+
+# Minimum test count
+export LAZYDEV_MIN_TESTS=3
+
+# Skip review for all tasks (not recommended)
+export LAZYDEV_SKIP_REVIEW=1
+```
+
+## Troubleshooting
+
+**Issue: Task ID not found**
+```bash
+# Check story files exist
+ls -la ./project-management/US-STORY/*/US-story.md
+
+# Search for task manually
+grep -r "TASK-003" ./project-management/US-STORY
+```
+
+**Issue: Tests not running**
+```bash
+# Check test framework installed
+pytest --version  # or: npm test
+
+# Check TDD configuration
+cat CLAUDE.md | grep -i tdd
+echo $LAZYDEV_ENFORCE_TDD
+```
+
+**Issue: Review not triggering**
+```bash
+# Reviews trigger automatically for:
+# - Complex tasks (security/auth/database)
+# - Multi-file changes
+# - Large estimates
+
+# To force review, set in task:
+### TASK-X: ... [REVIEW_REQUIRED]
+```
+
+---
+
+**Version:** 2.2.0
+**Status:** Production-Ready
+**Philosophy:** Accept anything, infer everything, build intelligently.