cursor-agent-scaffold 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cursor-agent-scaffold",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Scaffold package for setting up Cursor AI agent context and rules system",
   "keywords": [
     "cursor",
@@ -27,7 +27,7 @@
     "bin/"
   ],
   "bin": {
-    "cursor-scaffold": "./bin/install.js"
+    "cursor-scaffold": "bin/install.js"
   },
   "scripts": {
     "prepublishOnly": "node bin/verify.js"

package/rules/scaffold-agent-context.mdc

@@ -137,7 +137,7 @@ alwaysApply: true
 
 ### Step 3: Create Context Scaffold
 
-Create a `context-patterns.mdc` rule file that explains the context system:
+Create a `context-patterns.mdc` rule file that explains the context system and **automatic pattern detection**:
 
 ```markdown
 ---
@@ -147,24 +147,70 @@ globs:
 alwaysApply: true
 ---
 
-## Context Knowledge Base
+# Context Knowledge Base
 
 The `.cursor/context/` directory contains **learned patterns and knowledge** from working on this project. These files capture specific decisions, refactoring strategies, and best practices discovered during development.
 
-## How to Use Context Files
+## When Context Files Are Created
 
-1. **Before starting a task**, check if any context files are relevant
-2. **When encountering patterns** mentioned in context files, follow the documented approach
-3. **When making decisions**, reference the decision frameworks in context files
-4. **After implementing**, verify your approach aligns with documented patterns
+**CRITICAL: The agent MUST automatically detect and create context files when patterns emerge.**
 
-## Integration with Rules
+### Automatic Pattern Detection Triggers
 
-Context files complement the rules in `.cursor/rules/`:
-- **Rules** = Prescriptive guidelines and requirements
-- **Context** = Learned patterns, decision frameworks, and best practices
+Create a context file when you encounter ANY of these situations:
 
-Both should be considered when working on code.
+1. **Repeated Pattern (2+ occurrences)**
+   - Same code structure appears in 2+ files/components
+   - Same data fetching approach used multiple times
+   - Same styling pattern repeated across components
+   - **Action**: Create context file documenting the pattern
+
+2. **Decision Framework Needed**
+   - Multiple ways to solve the same problem exist
+   - A choice was made that will be relevant for future similar tasks
+   - **Action**: Document the decision framework in a context file
+
+3. **Domain-Specific Pattern**
+   - Framework-specific patterns (routing, data fetching, etc.)
+   - Component composition strategies
+   - Data transformation patterns
+   - **Action**: Create context file for the domain pattern
+
+4. **After Refactoring**
+   - Code was refactored and a reusable pattern was discovered
+   - **Action**: Document the refactored pattern in a context file
+
+### Pattern Detection Checklist
+
+During and after implementation, ask:
+- [ ] Is this pattern used in 2+ places? → Create context file
+- [ ] Will this decision be needed again? → Create context file
+- [ ] Is this a domain-specific pattern? → Create context file
+- [ ] Did I just refactor to a better pattern? → Create context file
+- [ ] Is this a complex pattern that others might struggle with? → Create context file
+
+## Automatic Context File Creation Workflow
+
+**MANDATORY: Follow this workflow after completing any implementation task:**
+
+1. **Pattern Detection Phase**
+   - Review the code you just wrote/modified
+   - Check if similar patterns exist elsewhere in the codebase
+   - Identify if this is a reusable pattern or decision framework
+
+2. **Context File Creation Phase**
+   - If a pattern is detected, IMMEDIATELY create a context file
+   - Use the template from this file (scaffold-agent-context.mdc)
+   - Include real examples from the codebase
+   - Reference specific files/components
+
+3. **Pattern Documentation**
+   - Document the "why" and "when" (not just "what")
+   - Include code examples from actual implementation
+   - Add anti-patterns to avoid
+   - Reference related files
+
+**Remember:** Rules tell you **what** to do. Context tells you **why** and **when**. **The agent MUST actively create context files, not wait for user requests.**
 ```
 
 ### Step 4: Document the System
@@ -192,16 +238,22 @@ Create a new rule file when:
 
 ### When to Create a New Context File
 
+**CRITICAL: The agent MUST automatically detect and create context files when patterns emerge.**
+
 Create a new context file when:
 - A refactoring reveals a reusable pattern
 - A decision framework is needed for similar tasks
 - Component composition strategies emerge
 - Domain-specific patterns are discovered
+- **A pattern appears in 2+ places** (automatic trigger)
+- **A complex pattern is implemented** (automatic trigger)
 
 **Example triggers:**
 - "We refactored the Button component and learned when to use variants vs separate components"
 - "We built three forms and discovered patterns for validation"
 - "We created a navigation system and learned external link handling patterns"
+- **Automatic**: Same data fetching pattern used in multiple components
+- **Automatic**: Same styling approach repeated across 2+ files
 
 ### Context File Template
 
@@ -265,13 +317,25 @@ When [situation], consider:
 
 ### Updating Context Files
 
+**MANDATORY Workflow:**
+
 When working on tasks:
 1. **Before starting:** Check relevant context files
 2. **During work:** Note patterns that emerge
-3. **After completion:** Update or create context files if:
-   - A new pattern was discovered
-   - A decision framework was developed
-   - An existing pattern needs clarification
+3. **After completion:** 
+   - **ALWAYS** run the pattern detection checklist
+   - **IMMEDIATELY** create context files if triggers are met
+   - Update existing context files if:
+     - A new pattern was discovered
+     - A decision framework was developed
+     - An existing pattern needs clarification
+
+**Pattern Detection Checklist (run after every implementation):**
+- [ ] Is this pattern used in 2+ places? → Create context file
+- [ ] Will this decision be needed again? → Create context file
+- [ ] Is this a domain-specific pattern? → Create context file
+- [ ] Did I just refactor to a better pattern? → Create context file
+- [ ] Is this a complex pattern that others might struggle with? → Create context file
 
 ### Updating Rules
 
@@ -325,13 +389,18 @@ Update rules when:
 
 ## Integration with Agent Behavior
 
-The agent should:
+The agent MUST:
 - **Always check relevant context files** before starting tasks
 - **Reference context files** when making decisions
-- **Update context files** when patterns are discovered
+- **Automatically detect patterns** during and after implementation
+- **IMMEDIATELY create context files** when pattern detection triggers are met
+- **Follow the mandatory workflow** after every implementation task
+- **Update context files** when patterns evolve
 - **Follow rules** as authoritative requirements
 - **Suggest rule updates** when patterns become project-wide
 
+**Critical:** The agent must PROACTIVELY create context files, not wait for user requests. Pattern detection is automatic and mandatory.
+
 ## Quick Reference
 
 | Type | Format | When to Create | Purpose |