claudify-agent 0.0.0-stage → 1.0.0

package/.claude/rules/plan-mode-execution.md

@@ -0,0 +1,289 @@
+# Plan Mode Execution Monitoring
+
+## Automatic Progress Tracking
+
+### TodoWrite Creation
+When plan approved:
+1. Convert steps to todos automatically
+2. First step: in_progress
+3. Update after EACH completion
+4. Only ONE in_progress at a time
+
+### Checkpoint Strategy
+Create checkpoint before:
+- Large refactors (>5 files)
+- Database changes
+- API contract changes
+- Breaking changes
+- Irreversible operations
+
+### Iteration Loops
+If tests fail:
+1. Use /grind automatically
+2. Max 5 iterations
+3. Update scratchpad
+4. Report if BLOCKED
+
+### Adaptive Re-planning
+If deviation >30%:
+1. Pause execution
+2. Create updated plan
+3. Present delta
+4. Get approval
+
+### Quality Gates
+After EACH step:
+- ReadLints on modified files
+- Fix introduced lints immediately
+- Run relevant tests
+- Update todos
+
+## Progress Tracking Template
+
+```markdown
+## Current Progress
+Step 3/7: Creating API endpoints (in_progress)
+
+## Completed Steps
+✅ Step 1: Research patterns (2 min)
+✅ Step 2: Create project structure (5 min)
+
+## Remaining Steps
+⏳ Step 3: Create API endpoints (in_progress)
+⏹ Step 4: Build UI components
+⏹ Step 5: Integration
+⏹ Step 6: Testing
+⏹ Step 7: Documentation
+
+## Quality Status
+- Lints: ✅ Clear
+- Tests: ✅ Passing
+- Checkpoints: 1 created (before Step 3)
+```
+
+## Checkpoint Guidelines
+
+### When to Create Checkpoints
+
+**ALWAYS create checkpoint before:**
+1. Database schema migrations
+2. API contract changes
+3. Authentication/authorization changes
+4. Payment processing changes
+5. Data migration
+6. Breaking changes
+7. Removing existing functionality
+
+**OPTIONAL checkpoints:**
+1. After completing major phases
+2. Before experimental changes
+3. When trying multiple approaches
+
+### Checkpoint Naming Convention
+
+```
+checkpoint-[plan-name]-step-[N]-[description]
+
+Examples:
+- checkpoint-auth-migration-step-3-before-db-change
+- checkpoint-dashboard-feature-step-2-before-api
+- checkpoint-checkout-refactor-step-5-before-breaking-change
+```
+
+### Rollback Triggers
+
+**Automatic rollback if:**
+1. Tests fail after 5 /grind iterations
+2. Critical linter errors introduced
+3. User requests rollback
+4. Agent detects critical error
+5. Data corruption detected
+
+## Iteration Loop (/grind)
+
+### When to Use
+- Tests failing
+- Linter errors persist
+- Matching design mockups
+- Fixing edge cases
+
+### Process
+1. Run tests → identify failures
+2. Fix code → run tests again
+3. Repeat until pass or max 5 iterations
+4. Update scratchpad: `.cursor/scratchpad.md`
+5. Report BLOCKED if stuck
+
+### Scratchpad Format
+
+```markdown
+## Task: Make all tests pass
+
+### Iteration 1
+- ❌ 3 tests failing
+- Fixed authentication logic
+
+### Iteration 2
+- ❌ 1 test failing
+- Fixed edge case in validation
+
+### Iteration 3
+- ✅ All tests passing
+- DONE
+```
+
+## Adaptive Re-planning
+
+### When to Re-plan
+
+**Re-plan required if:**
+1. >30% of plan steps changed
+2. New blockers discovered
+3. Time estimate off by >50%
+4. User changes requirements
+5. Critical dependency missing
+
+### Re-plan Process
+
+1. **Pause execution**
+   - Stop current step
+   - Create checkpoint if needed
+
+2. **Assess deviation**
+   - What changed?
+   - Why did it change?
+   - Impact on remaining steps?
+
+3. **Create updated plan**
+   - Show delta from original
+   - Explain why changes needed
+   - Provide new time estimate
+
+4. **Get approval**
+   - Present to user
+   - Explain trade-offs
+   - Wait for approval to continue
+
+### Re-plan Template
+
+```markdown
+## Plan Update Required
+
+### What Changed
+- Original: [what we planned]
+- Reality: [what we discovered]
+- Impact: [how it affects the plan]
+
+### Proposed Changes
+1. Add step: [new step]
+2. Remove step: [unnecessary step]
+3. Modify step: [changed step]
+4. New time estimate: [X minutes]
+
+### Reason for Changes
+[Brief explanation]
+
+### Approval Required
+Shall I proceed with this updated plan?
+```
+
+## Examples
+
+### Example 1: Normal Execution
+
+Plan: "Add login button" (5 steps)
+
+Execution:
+```
+✅ Step 1: Research patterns
+   - Tool: SemanticSearch
+   - ReadLints: Clear
+   - TodoWrite: Updated
+
+✅ Step 2: Add button to Header
+   - Tool: StrReplace
+   - ReadLints: Clear
+   - TodoWrite: Updated
+
+✅ Step 3: Style button
+   - Tool: Write
+   - ReadLints: Clear
+   - TodoWrite: Updated
+
+✅ Step 4: Add click handler
+   - Tool: StrReplace
+   - Tests: Pass
+   - TodoWrite: Updated
+
+✅ Step 5: Final validation
+   - Tool: ReadLints
+   - Tool: Shell (tests)
+   - All clear → COMPLETE
+```
+
+### Example 2: Tests Failing
+
+Plan: "Add authentication" (Step 4: Testing)
+
+Execution:
+```
+❌ Tests failing: 2 failures
+
+→ Automatic /grind loop:
+
+Iteration 1:
+- Fix: Token validation logic
+- Result: 1 test still failing
+
+Iteration 2:
+- Fix: Edge case for expired tokens
+- Result: All tests passing ✅
+
+→ Continue to next step
+```
+
+### Example 3: Checkpoint & Rollback
+
+Plan: "Migrate auth from JWT to sessions"
+
+Execution:
+```
+✅ Step 1: Research session patterns
+✅ Step 2: Add session dependencies
+
+📸 CHECKPOINT created: Before DB changes
+
+❌ Step 3: Database migration
+   - Error: Breaking change detected
+   - Tests failing
+
+→ Automatic rollback to checkpoint
+→ User notified
+→ Alternative approach suggested
+```
+
+### Example 4: Adaptive Re-planning
+
+Plan: "Add dashboard" (original: 5 steps)
+
+Discovery during execution:
+```
+⚠️ Discovered: Existing dashboard component
+⚠️ Impact: 3 steps unnecessary
+⚠️ New approach: Modify existing instead
+
+## Plan Update Required
+
+### What Changed
+- Original: Create new dashboard from scratch
+- Reality: Existing dashboard can be extended
+- Impact: 60% reduction in work
+
+### Proposed Changes
+1. Remove: Create new page file
+2. Remove: Create new layout
+3. Modify: Extend existing dashboard
+4. New time estimate: 20 minutes (was 45)
+
+Shall I proceed with updated plan?
+```

package/.claude/rules/plan-mode-research.md

@@ -0,0 +1,34 @@
+# Plan Mode Pre-Plan Research
+
+## Automatic Research Steps (Before ANY Plan)
+
+1. **SemanticSearch** (30s)
+   - Query: "How is [similar feature] implemented?"
+   - Target: Most relevant directory
+
+2. **Task Subagents** (60s, parallel)
+   - Launch 2-4 explore subagents
+   - Use model="fast", run_in_background=true
+
+3. **ReadLints** (15s)
+   - Check target files for existing issues
+
+4. **AskQuestion** (if ambiguous)
+   - Batch ALL questions in ONE call
+
+## Output
+- Summary of findings
+- Reference files for patterns
+- Clarified requirements (if asked)
+
+## Examples
+
+**Feature**: "Add user dashboard" → Research page/component patterns  
+**Bug**: "Fix auth bug" → Research auth implementation  
+**Refactor**: "Refactor checkout" → Research checkout code
+
+## Rules
+- Never plan without research (2-3 min max)
+- Use parallel subagents for complex tasks
+- Batch questions with AskQuestion
+- Follow patterns found in codebase

package/.claude/rules/plan-mode-structure.md

@@ -0,0 +1,166 @@
+# Plan Mode Plan Structure
+
+## Required Plan Sections
+
+Every plan MUST include:
+
+1. **Summary** (1-2 sentences)
+   - What will be done
+   - Why it's needed
+
+2. **Files to Create/Modify**
+   - Path and purpose
+   - Reference pattern: "Follow @[file]"
+   - Tools: "Use [tool] for [operation]"
+
+3. **Implementation Steps**
+   - Sequential ordering
+   - Tool for each step
+   - Success metric: "Tests pass", "Lints clear"
+
+4. **Tool Strategy**
+   - Exploration tools
+   - Implementation tools
+   - Validation tools
+   - Question strategy
+
+5. **Testing Strategy**
+   - Test types
+   - Test files to create/modify
+   - Commands to run
+
+6. **Risk Mitigation**
+   - High-risk steps flagged
+   - Fallback strategies
+   - Checkpoint locations
+
+7. **Estimated Time**
+   - Based on complexity
+   - Includes buffer (20%)
+
+## Plan Quality Gates
+
+- [ ] All steps verifiable
+- [ ] Tools specified
+- [ ] Patterns referenced
+- [ ] Risks identified
+- [ ] Tests included
+
+## Enhanced Plan Structure Template
+
+```markdown
+## Files to Create/Modify
+- `path/to/file.ts` - Purpose
+  - Pattern: Follow @[reference file]
+  - Tools: Use StrReplace for edits, Shell for testing
+
+## Implementation Steps
+1. [Step] 
+   - Tool: SemanticSearch to find [X]
+   - Tool: Task subagent to explore [Y]
+   - Tool: ReadLints to verify [Z]
+   - Success: [Verifiable metric]
+
+## Tool Strategy
+- Exploration: SemanticSearch + Task (explore)
+- Implementation: Read/Write/StrReplace
+- Validation: ReadLints + Shell (tests)
+- Questions: AskQuestion for [specific decisions]
+
+## Risk Mitigation
+- If [X] fails → Fallback: [Y]
+- If tests fail → Use /grind loop (max 5 iterations)
+- If stuck → AskQuestion with options
+```
+
+## Examples
+
+### Example 1: Simple Feature
+User: "Add login button"
+
+Plan structure:
+```markdown
+## Summary
+Add login button to header navigation following existing button patterns.
+
+## Files to Modify
+- `components/Header.tsx` - Add login button to nav
+  - Pattern: Follow @components/Button.tsx
+  - Tools: StrReplace for edit, ReadLints for validation
+
+## Implementation Steps
+1. Find existing button patterns
+   - Tool: SemanticSearch: "How are buttons styled?"
+   - Success: Pattern identified
+
+2. Add login button to Header
+   - Tool: StrReplace
+   - Success: Button renders correctly
+
+3. Verify no linting errors
+   - Tool: ReadLints
+   - Success: Zero new lints
+
+## Tool Strategy
+- Exploration: SemanticSearch for button patterns
+- Implementation: StrReplace
+- Validation: ReadLints
+
+## Estimated Time: 10 minutes
+```
+
+### Example 2: Complex Feature
+User: "Add user dashboard"
+
+Plan structure:
+```markdown
+## Summary
+Create user dashboard with stats, activity feed, and settings panel.
+
+## Files to Create
+- `app/dashboard/page.tsx` - Main dashboard page
+  - Pattern: Follow @app/profile/page.tsx
+  - Tools: Write for new file
+- `components/dashboard/StatsCard.tsx` - Stats component
+  - Pattern: Follow @components/Card.tsx
+  - Tools: Write for new file
+- `app/api/dashboard/stats/route.ts` - Stats API
+  - Pattern: Follow @app/api/users/route.ts
+  - Tools: Write for new file
+
+## Implementation Steps
+1. Research existing patterns (3 min)
+   - Tool: Task (explore): "Find page patterns"
+   - Tool: Task (explore): "Find component patterns"
+   - Success: Patterns identified
+
+2. Create API endpoint (5 min)
+   - Tool: Write
+   - Success: Endpoint created, tests pass
+
+3. Build dashboard page (10 min)
+   - Tool: Write
+   - Success: Page renders
+
+4. Create UI components (15 min)
+   - Tool: Write for each component
+   - Success: Components render
+
+5. Integration testing (5 min)
+   - Tool: Shell: npm run test
+   - Tool: ReadLints
+   - Success: All tests pass, zero lints
+
+## Tool Strategy
+- Exploration: Task (explore) x2 in parallel
+- Implementation: Write, StrReplace
+- Validation: Shell (tests), ReadLints
+- Questions: AskQuestion for dashboard widget priorities
+
+## Risk Mitigation
+- If API fails → Fallback: Mock data initially
+- If tests fail → Use /grind loop (max 5 iterations)
+- Checkpoint before: Integration step
+
+## Estimated Time: 45 minutes
+```

package/.claude/rules/plan-mode-validation.md

@@ -0,0 +1,130 @@
+# Plan Mode Plan Validation
+
+## Automatic Validation Steps
+
+Before presenting plan to user:
+
+1. **Feasibility Check**
+   - Task subagent: "Validate this plan"
+   - Check file accessibility
+   - Verify tool availability
+   - Estimate time accuracy
+
+2. **Dependency Analysis**
+   - Step ordering correct
+   - No missing prerequisites
+   - Parallel opportunities identified
+
+3. **Risk Assessment**
+   - High-risk steps flagged
+   - Fallback strategies defined
+   - Checkpoint locations set
+
+4. **Tool Availability**
+   - MCP servers running
+   - Permissions verified
+   - Alternative tools identified
+
+## Validation Output
+
+If PASS: Present plan to user
+If FAIL: 
+- List specific issues
+- Suggest fixes
+- Auto-correct if possible
+- Re-validate
+
+## Validation Checklist
+
+### Feasibility Check
+- [ ] All required files accessible
+- [ ] No circular dependencies
+- [ ] Estimated time realistic (based on complexity)
+- [ ] Tools available for all steps
+
+### Dependency Analysis
+- [ ] Step ordering correct
+- [ ] No missing prerequisites
+- [ ] Parallel opportunities identified
+
+### Risk Assessment
+- [ ] High-risk steps flagged
+- [ ] Fallback strategies defined
+- [ ] Rollback plan (Checkpoints) identified
+
+### Tool Availability
+- [ ] Required MCP servers running
+- [ ] Permissions verified
+- [ ] Alternative tools identified
+
+## Validation Subagent Pattern
+
+```
+Task:
+  description="Validate implementation plan"
+  prompt="Review this plan for feasibility:
+  
+  ## Plan to Validate
+  [Plan content]
+  
+  ## Validation Checklist
+  1. Check if all referenced files exist
+  2. Verify tool availability
+  3. Estimate actual time based on complexity
+  4. Identify potential blockers
+  5. Suggest improvements
+  
+  ## Output Format
+  Pass/Fail: [Your verdict]
+  Issues: [List specific problems]
+  Suggestions: [Concrete improvements]
+  Confidence: [High/Medium/Low]"
+  subagent_type="generalPurpose"
+  readonly=true
+```
+
+## Examples
+
+### Example 1: Simple Plan Validation
+
+Plan: "Add login button to header"
+
+Validation checks:
+- ✅ File exists: components/Header.tsx
+- ✅ Tool available: StrReplace
+- ✅ Time realistic: 10 minutes
+- ✅ No dependencies
+- ✅ Low risk
+
+Result: PASS → Present to user
+
+### Example 2: Complex Plan Validation
+
+Plan: "Migrate authentication from JWT to sessions"
+
+Validation checks:
+- ✅ Files accessible: src/auth/, app/api/auth/
+- ⚠️ Risk: Breaking change (checkpoint needed)
+- ⚠️ Time: 2 hours might be optimistic → suggest 3 hours
+- ✅ Tools available: Read, Write, Shell, ReadLints
+- ✅ Fallback: Keep JWT code until tests pass
+
+Result: PASS with warnings → Present with caveats
+
+### Example 3: Failed Validation
+
+Plan: "Rewrite entire backend in Rust"
+
+Validation checks:
+- ❌ Time unrealistic: 1 week → needs 2-3 months
+- ❌ Risk: Critical system rewrite
+- ❌ Missing: Testing strategy
+- ❌ Missing: Rollback plan
+- ❌ Dependencies: Team training needed
+
+Result: FAIL → Suggest phased approach:
+1. Start with non-critical service
+2. Add testing strategy
+3. Create rollback plan
+4. Revise time estimate
+5. Re-validate

package/.claude/rules/security-critical.md

@@ -0,0 +1,19 @@
+# Security-Critical Operations
+
+## Triggers
+Keywords: "auth", "security", "password", "token", "encrypt", "API key", "secret", "credential"
+
+## Critical Rules
+- Never hardcode credentials - use environment variables
+- Always validate and sanitize user input
+- Use parameterized queries (no SQL injection)
+- Hash passwords with bcrypt/argon2
+- Use strong crypto (SHA-256+, AES-256)
+
+## Security Checklist
+See `.cursor/security-report.md` for OWASP Top 10 checklist
+
+## Examples
+- Auth pattern: `@src/auth/validateToken.ts`
+- Password hashing: `@src/lib/password.ts`
+- Input validation: `@src/validators/userSchema.ts`

package/.claude/rules/tool-auto-selection.md

@@ -0,0 +1,45 @@
+# Tool Auto-Selection
+
+## Tool Cost Hierarchy (Start Cheap, Escalate)
+
+**Tier 1 (Cheapest)**: Read, Glob, Grep, Shell  
+**Tier 2 (Moderate)**: SemanticSearch, StrReplace, Write  
+**Tier 3 (Higher)**: Task, ReadLints  
+**Tier 4 (Most Expensive)**: Parallel subagents, Browser MCP
+
+## Automatic Triggers
+
+### After Code Changes
+- After StrReplace/Write → ReadLints (automatic)
+- After substantive changes → Shell (tests)
+
+### For Exploration
+- Know path? → Read  
+- Pattern? → Glob + Read  
+- Exact text? → Grep  
+- Concept? → SemanticSearch  
+- Broad? → Task (explore)
+
+### For Implementation
+- New file? → Write  
+- <50 lines? → StrReplace  
+- >50 lines? → Write (entire file)
+
+### For Complex Tasks
+- >10 steps or >5 files → Launch 3-4 parallel subagents
+
+## Rules
+
+1. Always start with Tier 1, escalate only if needed
+2. Never skip tiers unless justified
+3. Run ReadLints after EVERY code change
+4. Use parallel subagents for broad exploration (>3 files)
+
+## Decision Trees
+See `.cursor/skills/tool-selection/SKILL.md` for complete decision trees and patterns.
+
+## Anti-Patterns to Avoid
+- ❌ Tool hoarding (using 5 tools when 1 works)
+- ❌ Using expensive tools for simple tasks
+- ❌ Skipping validation after edits
+- ❌ No checkpoints for risky changes

package/.claude/rules/tool-strategy.md

@@ -0,0 +1,22 @@
+# Tool Selection Strategy
+
+## Cost Hierarchy (Start Cheap)
+Tier 1: Read, Glob, Grep (fastest)
+Tier 2: SemanticSearch, StrReplace, Write
+Tier 3: Task, Shell, ReadLints
+Tier 4: Parallel subagents, Browser MCP
+
+## Automatic Triggers
+- After edits → ReadLints automatically
+- After substantive changes → Shell (tests)
+- Ambiguous requirements → AskQuestion (batch)
+- Complex exploration → Task (parallel subagents)
+
+## MCP Servers
+- cursor-ide-browser: UI changes, visual verification
+- user-github: PR/issue operations
+- user-ESLint: Code quality checks
+- user-context7: Library documentation
+
+## Pattern
+Follow tool selection examples in @.cursor/skills/tool-selection/SKILL.md