Initial commit

commands/create-app-design.md

@@ -0,0 +1,322 @@
+---
+allowed-tools: Read, Glob, Grep, Write, MultiEdit, TodoWrite
+description: Generate comprehensive app design document with project stage assessment
+---
+
+# Generate Application Design Document
+
+**User Request:** $ARGUMENTS
+
+## Context
+
+- Project root: !`pwd`
+- Package.json: @package.json
+- Existing design docs: !`ls -la .claude/rules/ 2>/dev/null || echo "No .claude/rules directory yet"`
+
+## Goal
+
+Create a comprehensive Application Design Document based on deep codebase analysis and user input. The document provides a high-level overview of the application's architecture, core features, user experience, and business logic while remaining technology-agnostic and focused on the "what" rather than the "how".
+
+## Process
+
+### 1. Initial Analysis
+
+- Analyze project structure and existing codebase
+- Review package.json for project name and dependencies
+- Check for existing documentation in .claude/rules/
+- Identify key application features and patterns
+- **Think deeply** about the application's purpose and architecture
+
+### 2. Codebase Deep Dive
+
+**Think harder about the application's architecture and business logic.**
+
+Analyze the codebase to understand:
+
+- **Application Structure:** Main modules, features, and components
+- **User Flows:** Authentication, navigation, key user journeys
+- **Data Models:** Conceptual relationships and entities
+- **Business Logic:** Core rules, workflows, and processes
+- **Integrations:** External services and APIs
+- **Security Patterns:** Authentication and authorization approaches
+
+_Extended thinking helps identify non-obvious patterns, understand complex business rules from code, and make strategic decisions about what aspects are most important to document._
+
+### 3. Interactive Q&A Session
+
+**CRITICAL:** Ask project stage question FIRST, then 4-7 additional questions:
+
+- Use lettered/numbered options for easy response
+- Focus on business goals and user needs
+- Gather context for proper documentation
+
+### 4. Update Project Configuration
+
+Based on project stage response:
+
+- Update `.claude/rules/3-project-status.mdc` with current stage
+- Set appropriate DO/DON'T priorities for the stage
+- Document stage-specific development guidelines in the Cursor rule
+
+### 5. Generate Document
+
+Create comprehensive app design document following the standard structure
+
+### 6. Save and Organize
+
+- Create `.claude/rules/` directory if needed
+- Save as `1-app-design-document.mdc`
+- Suggest next steps (tech stack doc, PRD, etc.)
+
+## Required Questions Template
+
+### 🎯 CRITICAL: Project Stage Assessment (Ask First!)
+
+**1. What stage is your application currently in?**
+
+a) **Pre-MVP** - Building initial version, not deployed to production yet  
+ b) **MVP** - Basic version deployed and live with early users  
+ c) **Production** - Mature application with established user base  
+ d) **Enterprise** - Large scale deployment, multiple teams involved
+
+**2. Based on your selected stage, here are the development priorities:**
+
+- **Pre-MVP Priorities:**
+
+  - ✅ DO: Core functionality, security basics, input validation, working features
+  - ❌ DON'T: Unit tests, performance optimization, accessibility polish, perfect code
+  - 🚀 Focus: Ship fast with security, iterate based on feedback
+
+- **MVP Priorities:**
+
+  - ✅ DO: Critical path testing, basic monitoring, user feedback loops
+  - ❌ DON'T: Comprehensive test coverage, advanced patterns, premature optimization
+  - 🚀 Focus: Stability for early users, rapid iteration
+
+- **Production Priorities:**
+
+  - ✅ DO: Testing, monitoring, performance, accessibility, documentation
+  - ❌ DON'T: Skip security reviews, ignore technical debt
+  - 🚀 Focus: Reliability, scalability, user experience
+
+- **Enterprise Priorities:**
+  - ✅ DO: Comprehensive testing, security audits, team coordination, compliance
+  - ❌ DON'T: Skip documentation, ignore code standards
+  - 🚀 Focus: Team efficiency, maintainability, compliance
+
+### 📋 Context-Specific Questions (Ask 4-7 based on analysis)
+
+**3. Application Purpose & Users**
+
+- What is the primary problem your application solves?
+- Who are your target users and what are their main goals?
+
+**4. Unique Value Proposition**
+
+- What makes your application unique compared to existing solutions?
+- What's your competitive advantage?
+
+**5. User Roles & Permissions**
+
+- What different types of users interact with your system?
+- Examples: end users, admins, moderators, content creators, viewers
+
+**6. Core User Journeys**
+
+- What are the 2-3 most critical user flows?
+- Example: Sign up → Create content → Share → Get feedback
+
+**7. Business Model & Growth**
+
+- How does this application generate value?
+- Options: SaaS subscription, marketplace, freemium, advertising, one-time purchase
+
+**8. Integration Ecosystem**
+
+- What external services must you integrate with?
+- Examples: payment processors, email services, analytics, social platforms
+
+**9. Scale & Performance Goals**
+
+- What scale are you planning for in the next 12 months?
+- Users: dozens, hundreds, thousands, millions?
+- Geographic: local, national, global?
+
+**10. Success Metrics**
+
+- How will you measure if your application is successful?
+- Examples: user retention, revenue, engagement, conversion rates
+
+## Document Structure
+
+The generated document must follow this high-level structure:
+
+### **Introduction**
+
+- Application overview and purpose
+- Target audience and user base
+- Core value proposition
+- Business context and goals
+
+### **Core Features**
+
+- **Feature Category 1:** (e.g., User Management)
+  - Purpose and user benefit
+  - Key functionalities
+  - User experience considerations
+- **Feature Category 2:** (e.g., Content Creation)
+  - Purpose and user benefit
+  - Key functionalities
+  - User experience considerations
+- **[Additional feature categories as needed]**
+
+### **User Experience**
+
+- User personas and roles
+- Key user journeys and flows
+- Interface design principles
+- Accessibility and usability considerations
+
+### **System Architecture**
+
+- High-level system components
+- Data flow and relationships
+- Integration points and external services
+- Security and privacy approach
+
+### **Business Logic**
+
+- Core business rules and processes
+- Data models and relationships (conceptual)
+- Workflow and state management
+- Validation and business constraints
+
+### **Future Considerations**
+
+- Planned enhancements and features
+- Scalability considerations
+- Potential integrations
+- Long-term vision and roadmap
+
+## Target Audience
+
+The document should be accessible to:
+
+- **Business stakeholders** who need to understand the application's purpose and capabilities
+- **Product managers** planning features and roadmaps
+- **Designers** creating user interfaces and experiences
+- **New developers** joining the project who need a high-level understanding
+- **Technical leaders** making architectural decisions
+
+The language should be clear, business-focused, and avoid technical implementation details.
+
+## Writing Principles
+
+### DO:
+
+- **Business Focus:** Describe WHAT the application does, not HOW
+- **User Value:** Emphasize benefits and outcomes for users
+- **Clear Language:** Write for non-technical stakeholders
+- **Visual Thinking:** Use diagrams and flows where helpful
+- **Future Ready:** Consider growth and evolution paths
+
+### DON'T:
+
+- **Technical Details:** No code snippets or implementation specifics
+- **Technology Stack:** Save for 2-tech-stack.mdc document
+- **Database Schemas:** Keep data models conceptual
+- **API Specifications:** Focus on capabilities, not endpoints
+- **Performance Metrics:** Describe goals, not technical benchmarks
+
+## Output
+
+- **Format:** Markdown (`.mdc`)
+- **Location:** `.claude/rules/`
+- **Filename:** `1-app-design-document.mdc`
+
+## Execution Steps
+
+### 1. Start with Analysis
+
+- Use Read, Glob, and Grep to explore the codebase
+- Identify key features and patterns
+- Look for existing documentation
+- **Use extended thinking:** "Think deeply about this codebase's architecture, business purpose, and how different components work together to serve users"
+
+### 2. Interactive Q&A
+
+- **MUST ASK PROJECT STAGE FIRST**
+- Present questions with numbered/lettered options
+- Wait for user responses before proceeding
+
+### 3. Update Project Status in Cursor Rule
+
+Update `.claude/rules/3-project-status.mdc` with the project stage information:
+
+```markdown
+---
+description: Project status and stage-specific development guidelines
+globs:
+alwaysApply: true
+---
+
+# Project Status Guidelines
+
+## Current Project Stage: [Stage Name]
+
+**Stage**: [Pre-MVP | MVP | Production | Enterprise]
+
+### DO Care About (Current Stage Priorities)
+
+[Stage-specific DO priorities from template below]
+
+### DO NOT Care About (Skip for Velocity)
+
+[Stage-specific DON'T priorities from template below]
+
+### Development Approach
+
+[Stage-specific development focus]
+
+## Stage-Based Development Guidelines
+
+[Keep existing stage categories and guidelines from the original file]
+```
+
+**Stage-Specific Content:**
+
+- **Pre-MVP**:
+
+  - ✅ DO: Core functionality, security basics, input validation, working features
+  - ❌ DON'T: Unit tests, performance optimization, accessibility polish, perfect code
+  - 🚀 Focus: Ship fast with security, iterate based on feedback
+
+- **MVP**:
+
+  - ✅ DO: Critical path testing, basic monitoring, user feedback loops
+  - ❌ DON'T: Comprehensive test coverage, advanced patterns, premature optimization
+  - 🚀 Focus: Stability for early users, rapid iteration
+
+- **Production**:
+
+  - ✅ DO: Testing, monitoring, performance, accessibility, documentation
+  - ❌ DON'T: Skip security reviews, ignore technical debt
+  - 🚀 Focus: Reliability, scalability, user experience
+
+- **Enterprise**:
+  - ✅ DO: Comprehensive testing, security audits, team coordination, compliance
+  - ❌ DON'T: Skip documentation, ignore code standards
+  - 🚀 Focus: Team efficiency, maintainability, compliance
+
+### 4. Generate Document
+
+- Follow the standard structure
+- Tailor content to project stage
+- Keep language accessible
+
+### 5. Save and Next Steps
+
+- Create directories: `mkdir -p .claude/docs .claude/rules`
+- Save design document: `.claude/rules/1-app-design-document.mdc`
+- Update Claude rule: `.claude/rules/3-project-status.mdc`
+- Suggest: "Would you like me to create a technical stack document next?"

commands/create-snippet.md

@@ -0,0 +1,32 @@
+Title: Create Snippet Prompt
+Description: Generates a snippet template based on provided example code. Template contains instructions and example code. Provide more examples for coverage if needed. Don't include obvious steps you already know like imports.
+Body:
+
+### Instructions
+
+Title: ${1:Create ${2:Component}}
+Description: Generates a template for ${3:a ${2}}
+Rules:
+
+- ${4:Add relevant rules here}
+- Keep rules concise and specific to the snippet
+- Include any critical requirements or conventions
+- Add validation rules if applicable
+
+Body:
+
+${5:$TM_SELECTED_TEXT}
+
+### Example
+
+Title: ${1}
+Description: ${3}
+Rules:
+
+- ${4}
+- Example rule 2
+- Example rule 3
+
+Body:
+
+${5}

commands/create-tech-stack.md

@@ -0,0 +1,329 @@
+---
+allowed-tools: Read, Glob, Grep, Write, MultiEdit, TodoWrite, Bash
+description: Generate comprehensive technical stack documentation from codebase analysis
+---
+
+# Generate Tech Stack Documentation
+
+**User Request:** $ARGUMENTS
+
+## Context
+
+- Project root: !`pwd`
+- Package.json: @package.json
+- Node version: !`node --version 2>/dev/null || echo "Node.js not found"`
+- TypeScript config: @tsconfig.json
+- Database schema: !`ls -la prisma/schema.prisma 2>/dev/null || echo "No Prisma schema found"`
+- Existing docs: !`ls -la .claude/rules/*.md 2>/dev/null || echo "No docs yet"`
+
+## Goal
+
+Create comprehensive Tech Stack Documentation based on deep codebase analysis. Document all technologies, frameworks, libraries, development tools, deployment strategies, and implementation patterns with specific versions and configurations.
+
+## Process
+
+### 1. Automated Technical Discovery
+
+- Parse package.json for all dependencies
+- Analyze configuration files (tsconfig, vite.config, next.config, etc.)
+- Detect database setup (Prisma, Drizzle, TypeORM, etc.)
+- Identify testing frameworks and tools
+- Scan for CI/CD configurations
+- Check deployment configurations
+
+### 2. Deep Code Analysis
+
+Examine codebase for:
+
+- **Architecture Patterns:** Monorepo structure, module organization
+- **Framework Usage:** Next.js app router vs pages, API routes
+- **State Management:** Zustand, Redux, Context API patterns
+- **Styling Approach:** Tailwind, CSS modules, styled-components
+- **Type Safety:** TypeScript strictness, validation libraries
+- **API Design:** REST, GraphQL, tRPC implementation
+- **Authentication:** Auth libraries and session management
+- **Testing Strategy:** Unit, integration, E2E test patterns
+
+### 3. Interactive Technical Q&A
+
+Ask 4-6 deployment and infrastructure questions:
+
+- Use numbered/lettered options
+- Focus on non-discoverable information
+- Gather hosting, monitoring, and workflow details
+
+### 4. Generate Comprehensive Documentation
+
+Create detailed tech stack document with:
+
+- Specific version numbers
+- Configuration examples
+- Command references
+- Architecture diagrams (when applicable)
+
+### 5. Save and Organize
+
+- Create `.claude/rules/` if needed
+- Save as `2-tech-stack.mdc`
+
+## Technical Questions Template
+
+### 🚀 Deployment & Infrastructure
+
+**1. Where is your application currently deployed?**
+
+a) **Vercel** - Next.js optimized hosting  
+ b) **AWS** - EC2, Lambda, or containerized  
+ c) **Railway/Render** - Modern PaaS providers  
+ d) **Self-hosted** - VPS or on-premise  
+ e) **Other** - Please specify  
+ f) **Not deployed yet** - Still in development
+
+**2. How is your database hosted?**
+
+a) **Managed service** (Supabase, PlanetScale, Neon, etc.)  
+ b) **Cloud provider** (AWS RDS, Google Cloud SQL, etc.)  
+ c) **Self-hosted** (Docker, VPS, etc.)  
+ d) **Local only** - No production database yet
+
+### 📊 Monitoring & Operations
+
+**3. What observability tools do you use?**
+
+a) **Error tracking:** Sentry, Rollbar, Bugsnag  
+ b) **Analytics:** Vercel Analytics, Google Analytics, Plausible  
+ c) **Monitoring:** Datadog, New Relic, custom solution  
+ d) **Logging:** CloudWatch, LogTail, custom logs  
+ e) **None yet** - Planning to add later
+
+### 👥 Development Workflow
+
+**4. What's your Git workflow?**
+
+a) **Feature branches** with PR reviews  
+ b) **Trunk-based** development  
+ c) **GitFlow** with release branches  
+ d) **Direct to main** (solo project)
+
+**5. How do you manage environments?**
+
+a) **Multiple deployments** (dev, staging, prod)  
+ b) **Preview deployments** for PRs  
+ c) **Single production** environment  
+ d) **Local development** only
+
+### 🔐 Additional Services
+
+**6. Which external services do you integrate with?**
+
+- [ ] Payment processing (Stripe, PayPal)
+- [ ] Email service (SendGrid, Resend, AWS SES)
+- [ ] File storage (S3, Cloudinary, UploadThing)
+- [ ] Authentication (Auth0, Clerk, Supabase Auth)
+- [ ] Search (Algolia, Elasticsearch)
+- [ ] Other APIs (please specify)
+
+## Document Structure
+
+The generated document must follow this technical structure:
+
+### **Overview**
+
+- Brief description of the application's technical nature
+- Technology stack summary
+- Architecture approach (monolith, microservices, etc.)
+
+### **Programming Language & Runtime**
+
+- Primary programming language and version
+- Runtime environment and version
+- Type system and language features used
+
+### **Frontend**
+
+- UI Framework/Library and version
+- Styling approach and frameworks
+- Component libraries and design systems
+- State management solutions
+- Build tools and bundlers
+- Browser support and compatibility
+
+### **Backend**
+
+- Backend framework and architecture
+- API design (REST, GraphQL, tRPC, etc.)
+- Authentication and authorization
+- Middleware and security
+- File handling and uploads
+
+### **Database & Storage**
+
+- Database type and version
+- ORM/Query builder
+- Schema management and migrations
+- Caching solutions
+- File storage solutions
+- Data backup and recovery
+
+### **Development Tools & Workflow**
+
+- Package manager
+- Code formatting and linting
+- Type checking and compilation
+- Testing frameworks and strategies
+- Development server and hot reload
+- Version control workflow
+
+### **Deployment & Infrastructure**
+
+- Hosting platform and services
+- Build and deployment pipeline
+- Environment configuration
+- Domain and DNS management
+- SSL/TLS and security
+- Monitoring and logging
+
+### **External Integrations**
+
+- Third-party APIs and services
+- Payment processing
+- Email services
+- Analytics and tracking
+- Error monitoring
+- Performance monitoring
+
+### **Quality Assurance & Testing**
+
+- Testing strategy and frameworks
+- Code coverage tools
+- End-to-end testing
+- Performance testing
+- Security testing
+- Code review process
+
+### **Schemas & Data Models**
+
+- Database schema (if applicable)
+- API schemas and validation
+- Type definitions and interfaces
+- Data relationships and constraints
+
+## Target Audience
+
+The document should serve:
+
+- **Developers** joining the project who need technical onboarding
+- **DevOps engineers** setting up infrastructure and deployment
+- **Technical architects** evaluating or improving the tech stack
+- **Security teams** understanding the technical landscape
+- **Future maintainers** who need to understand technical decisions
+
+The language should be technical, precise, and include specific version numbers and configuration details.
+
+## Documentation Principles
+
+### DO Include:
+
+- **Exact Versions:** Lock file versions, not just ranges
+- **Configuration Examples:** Actual config snippets from the project
+- **Command Reference:** All npm scripts and their purposes
+- **Setup Instructions:** Step-by-step for new developers
+- **Architecture Decisions:** Why specific technologies were chosen
+- **Integration Details:** How services connect and communicate
+
+### DON'T Include:
+
+- **Generic Descriptions:** Avoid Wikipedia-style explanations
+- **Outdated Information:** Only document what's actually used
+- **Wishful Thinking:** Document current state, not future plans
+- **Sensitive Data:** No API keys, secrets, or credentials
+- **Redundant Info:** Link to official docs instead of copying
+
+## Output
+
+- **Format:** Markdown (`.mdc`)
+- **Location:** `.claude/rules/`
+- **Filename:** `2-tech-stack.mdc`
+
+## Execution Steps
+
+### 1. Automated Analysis Phase
+
+```bash
+# Extract key technical information
+- Read package.json and lock files
+- Scan for configuration files
+- Detect framework patterns
+- Identify database setup
+- Find test configurations
+```
+
+### 2. Manual Discovery Phase
+
+- Read key source files to understand architecture
+- Check for API route patterns
+- Analyze authentication implementation
+- Review deployment configurations
+
+### 3. Interactive Q&A
+
+- Present deployment and infrastructure questions
+- Use checkboxes for multi-select options
+- Wait for user responses
+
+### 4. Document Generation
+
+- Start with discovered information
+- Incorporate user responses
+- Add specific configuration examples
+- Include all npm scripts with descriptions
+
+### 5. Save and Update
+
+```bash
+# Create directory and save
+mkdir -p .claude/docs
+# Save to .claude/rules/2-tech-stack.mdc
+```
+
+### 6. Next Steps
+
+- Recommend: "Should I create an app design document to complement this technical documentation?"
+
+## Example Usage
+
+```bash
+# Basic usage
+/project:create-tech-stack
+
+# With specific focus
+/project:create-tech-stack Focus on deployment and CI/CD setup
+```
+
+## Sample Output Structure
+
+```markdown
+# Tech Stack Documentation
+
+## Overview
+
+- **Framework:** Next.js 14.2.5 (App Router)
+- **Language:** TypeScript 5.5.3
+- **Database:** PostgreSQL with Prisma ORM
+- **Deployment:** Vercel with preview deployments
+
+## Commands Reference
+
+### Development
+
+- `pnpm dev` - Start Next.js dev server on port 3000
+- `pnpm build` - Build production bundle
+- `pnpm typecheck` - Run tsc --noEmit
+
+### Database
+
+- `pnpm db:generate` - Generate Prisma client
+- `pnpm db:push` - Push schema changes to database
+
+# ... continue with full documentation
+```

commands/fix.md

@@ -0,0 +1 @@
+Read and fix the errors you can see in the Bash output.

commands/install-all.md

@@ -0,0 +1,22 @@
+---
+description: Install all dotai registry items in one command
+allowed-tools: Bash
+---
+
+# Install All
+
+Install all dotai registry items (dotai, flashback, prompt) in one command:
+
+```bash
+npx shadcn@latest add https://raw.githubusercontent.com/udecode/dotai/main/registry/all.json
+```
+
+After installation, add ruler postinstall to your `package.json` to auto-generate agent instructions:
+
+```json
+{
+  "scripts": {
+    "postinstall": "npx skiller@latest apply"
+  }
+}
+```

commands/install.md

@@ -0,0 +1,12 @@
+---
+description: Install dotai prerequisites and project setup files
+allowed-tools: Bash
+---
+
+# Install dotai Prerequisites
+
+Initialize your project with dotai setup files using shadcn CLI:
+
+```bash
+npx shadcn@latest add https://raw.githubusercontent.com/udecode/dotai/main/registry/dotai.json
+```

commands/opus.md

@@ -0,0 +1,5 @@
+---
+model: claude-opus-4-1-20250805
+---
+
+$ARGUMENTS

commands/update-app-design.md

@@ -0,0 +1,302 @@
+---
+allowed-tools: Read, Glob, Grep, Write, MultiEdit, TodoWrite, Bash
+description: Update existing app design document based on codebase changes and project evolution
+---
+
+# Sync Application Design Document
+
+**User Request:** $ARGUMENTS
+
+## Context
+
+- Project root: !`pwd`
+- Package.json: @package.json
+- Current design doc: @.claude/rules/1-app-design-document.mdc
+- Last modified: !`stat -f "%Sm" .claude/rules/1-app-design-document.mdc 2>/dev/null || echo "No existing document"`
+
+## Goal
+
+Update the existing Application Design Document to reflect current codebase state, new features, changed priorities, and project evolution. Maintain consistency with the original document while incorporating new information.
+
+## Process
+
+### 1. Document Analysis
+
+- Read and understand the existing 1-app-design-document.mdc
+- Establish baseline understanding of documented features
+- Note the document's structure and tone
+- Identify areas that may need updates
+
+### 2. Codebase Change Detection
+
+**Think deeply about what has changed in the codebase since the document was last updated.**
+
+Analyze for:
+
+- **New Features:** Components, modules, or capabilities added
+- **Modified Flows:** Changes to user journeys or business logic
+- **Removed Features:** Deprecated or deleted functionality
+- **Architecture Evolution:** New patterns, services, or integrations
+- **Scale Changes:** Growth in complexity or user base
+- **Security Updates:** New authentication/authorization patterns
+
+_Extended thinking helps identify subtle changes, understand how new features integrate with existing ones, and recognize patterns that indicate architectural evolution._
+
+### 3. Interactive Update Session
+
+**CRITICAL:** Ask project stage question FIRST to assess if priorities have changed:
+
+- Use lettered/numbered options for easy response
+- Focus on what has changed and why
+- Gather context for accurate updates
+
+### 4. Update Project Configuration
+
+If project stage or priorities have changed:
+
+- Update `.claude/rules/3-project-status.mdc`
+- Adjust DO/DON'T lists for new priorities
+- Document any stage transitions
+
+### 5. Sync Document
+
+Update the document incrementally:
+
+- Preserve accurate existing content
+- Add new sections only when necessary
+- Update outdated information
+- Maintain consistent tone and structure
+
+### 6. Save Updated Document
+
+- Backup suggestion if major changes
+- Overwrite existing 1-app-design-document.mdc
+- Note what was updated
+
+## Required Questions Template
+
+### 🎯 CRITICAL: Project Evolution Assessment (Ask First!)
+
+**1. Has your project stage evolved since the last update?**
+
+a) **Same Stage** - Still in [current stage], just adding features  
+b) **Stage Evolution** - Moved from [current] to next stage  
+c) **Major Pivot** - Significant change in direction or purpose  
+d) **Help Me Assess** - Let's review current state together
+
+**2. Have your development priorities changed?**
+
+Based on your current stage, are these still your priorities?
+
+[Show current DO/DON'T lists from `.claude/rules/3-project-status.mdc`]
+
+a) **Same Priorities** - These still reflect our focus  
+b) **Adjusted Priorities** - Some changes needed (please specify)  
+c) **New Focus Areas** - Different priorities based on learnings  
+d) **Stage-Based Change** - Priorities changed due to stage evolution
+
+### 📊 Change Identification Questions
+
+**3. What major features have been added?**
+
+Please describe any significant new capabilities, modules, or user-facing features added since the last update.
+
+**4. Have any core user flows changed?**
+
+a) **Authentication/Authorization** - Login, permissions, security  
+b) **Main User Journey** - Primary application workflow  
+c) **Data Management** - How users create/edit/delete data  
+d) **Integration Points** - External service connections  
+e) **None/Minor Only** - No significant flow changes
+
+**5. What has been removed or deprecated?**
+
+List any features, integrations, or capabilities that have been removed or are being phased out.
+
+**6. Have you integrated new external services?**
+
+a) **Payment Processing** - Stripe, PayPal, etc.  
+b) **Communication** - Email, SMS, notifications  
+c) **Analytics/Monitoring** - Tracking, logging services  
+d) **AI/ML Services** - LLMs, image processing, etc.  
+e) **Other** - Please specify  
+f) **None** - No new integrations
+
+### 🚀 Future Direction Questions
+
+**7. How has user feedback influenced changes?**
+
+Describe any significant pivots or adjustments made based on user feedback or usage patterns.
+
+**8. What are your updated success metrics?**
+
+Have your KPIs or success measurements changed? Current focus:
+
+- User growth targets?
+- Revenue goals?
+- Engagement metrics?
+- Performance benchmarks?
+
+**9. What's the next major milestone?**
+
+a) **Feature Release** - Specific new capability  
+b) **Scale Milestone** - User/revenue target  
+c) **Technical Goal** - Performance, security, architecture  
+d) **Business Goal** - Partnerships, funding, market expansion
+
+## Update Strategy
+
+### Incremental Updates
+
+- **Preserve:** Keep accurate existing content
+- **Enhance:** Add new information to existing sections
+- **Replace:** Update outdated or incorrect information
+- **Remove:** Mark deprecated features appropriately
+
+### Change Documentation
+
+- **New Features:** Add to relevant feature categories
+- **Modified Flows:** Update user journey descriptions
+- **Architecture Changes:** Reflect in system architecture section
+- **Business Evolution:** Update goals and success metrics
+
+### Consistency Maintenance
+
+- Keep the same professional, accessible tone
+- Maintain technology-agnostic descriptions
+- Focus on WHAT not HOW
+- Preserve document structure
+
+## Document Update Areas
+
+### Always Review:
+
+1. **Introduction**
+
+   - Update if purpose or audience has shifted
+   - Reflect any pivot in value proposition
+
+2. **Core Features**
+
+   - Add new feature categories if needed
+   - Update existing features with enhancements
+   - Mark removed features as deprecated
+
+3. **User Experience**
+
+   - Update user journeys with new flows
+   - Add new user personas if applicable
+   - Reflect UI/UX improvements
+
+4. **System Architecture**
+
+   - Add new integrations
+   - Update data flow diagrams
+   - Reflect new security patterns
+
+5. **Business Logic**
+
+   - Update rules and workflows
+   - Reflect new validation requirements
+   - Document new business constraints
+
+6. **Future Considerations**
+   - Update roadmap based on progress
+   - Add new planned features
+   - Reflect lessons learned
+
+## Execution Steps
+
+### 1. Start with Analysis
+
+```bash
+# Check when document was last updated
+stat -f "%Sm" .claude/rules/1-app-design-document.mdc
+
+# Review recent commits for feature changes
+git log --oneline --since="30 days ago" | head -20
+```
+
+**Think deeply about:** "What has fundamentally changed in this application? How have new features altered the original vision? What patterns indicate architectural evolution?"
+
+### 2. Interactive Q&A
+
+- **MUST ASK PROJECT STAGE FIRST**
+- Present all questions clearly
+- Wait for complete responses
+
+### 3. Update Project Status (if needed)
+
+If stage or priorities changed, update both:
+
+```markdown
+# In `.claude/rules/3-project-status.mdc`
+
+## Project Status
+
+**Current Stage**: [New Stage]
+
+### DO Care About (Production-Ready Foundation)
+
+[Updated priorities]
+
+### DO NOT Care About (Skip for Velocity)
+
+[Updated items to skip]
+```
+
+### 4. Sync Document
+
+- Make targeted updates
+- Preserve document quality
+- Add version note if helpful:
+
+```markdown
+<!-- Last updated: [date] - Major changes: [summary] -->
+```
+
+### 5. Save and Backup
+
+```bash
+# Optional: Create backup
+cp .claude/rules/1-app-design-document.mdc .claude/rules/1-app-design-document.backup.mdc
+
+# Save updated document
+# Overwrite .claude/rules/1-app-design-document.mdc
+```
+
+## Key Principles
+
+### DO:
+
+- **Preserve Quality:** Maintain document's professional tone
+- **Incremental Updates:** Don't rewrite unnecessarily
+- **Clear Changes:** Make updates obvious and well-integrated
+- **User Focus:** Keep emphasis on user value
+- **Stage Awareness:** Align with current project maturity
+
+### DON'T:
+
+- **Complete Rewrite:** Unless fundamentally pivoted
+- **Technical Details:** Maintain high-level focus
+- **Break Structure:** Keep established organization
+- **Lose History:** Preserve context of major decisions
+- **Skip Analysis:** Always understand current state first
+
+## Output
+
+- **Format:** Markdown (`.mdc`)
+- **Location:** `.claude/rules/`
+- **Filename:** `1-app-design-document.mdc` (overwrites)
+- **Backup:** Suggest if major changes
+
+## Final Checklist
+
+1. ✅ Read existing document completely
+2. ✅ Analyze codebase changes thoroughly
+3. ✅ Ask project stage question FIRST
+4. ✅ Update `.claude/rules/3-project-status.mdc` if stage/priorities changed
+5. ✅ Make incremental, targeted updates
+6. ✅ Preserve document quality and tone
+7. ✅ Suggest backup for major changes
+8. ✅ Consider 2-tech-stack.mdc updates if needed

commands/update-project-structure.md

@@ -0,0 +1,10 @@
+---
+allowed-tools: Bash
+description: Update project structure documentation by running tree script
+---
+
+This command is generating the project structure documentation:
+
+!`bash ~/.claude/plugins/marketplaces/dotai/.claude-plugin/plugins/dotai/scripts/tree.sh`
+
+Do not do anything else.

commands/update-tech-stack.md

@@ -0,0 +1,312 @@
+---
+allowed-tools: Read, Glob, Grep, Write, MultiEdit, TodoWrite, Bash
+description: Update tech stack documentation based on dependency changes and technical evolution
+---
+
+# Update Tech Stack Documentation
+
+**User Request:** $ARGUMENTS
+
+## Context
+
+- Project root: !`pwd`
+- Package.json: @package.json
+- Current tech doc: @.claude/rules/2-tech-stack.mdc
+- Last modified: !`stat -f "%Sm" .claude/rules/2-tech-stack.mdc 2>/dev/null || echo "No existing document"`
+- Recent package changes: !`git diff HEAD~10 HEAD -- package.json 2>/dev/null | grep -E "^[+-]" | head -20 || echo "No recent changes"`
+
+## Goal
+
+Update the existing Tech Stack Documentation to reflect current technical state, dependency changes, new tools adoption, and infrastructure evolution. Maintain technical accuracy while documenting all changes.
+
+## Process
+
+### 1. Document Analysis
+
+- Read existing 2-tech-stack.mdc thoroughly
+- Note documented versions and configurations
+- Understand current technical baseline
+- Identify sections that may need updates
+
+### 2. Technical Change Detection
+
+**Think deeply about technical evolution in the codebase.**
+
+Analyze for:
+
+- **Dependency Changes:** New packages, version updates, removals
+- **Framework Evolution:** Major version upgrades, breaking changes
+- **Tool Adoption:** New dev tools, linters, formatters, testing frameworks
+- **Infrastructure Shifts:** Deployment, hosting, monitoring changes
+- **Database Evolution:** Schema changes, new ORMs, migrations
+- **Integration Updates:** New APIs, services, authentication providers
+
+_Extended thinking helps identify cascading dependency updates, understand version compatibility issues, and recognize architectural implications of technical changes._
+
+### 3. Automated Comparison
+
+```bash
+# Compare current vs documented dependencies
+# Check for version mismatches
+# Identify new configuration files
+# Detect new tool configurations
+```
+
+### 4. Interactive Technical Q&A
+
+Ask targeted questions about:
+
+- Non-discoverable infrastructure changes
+- Deployment and hosting updates
+- New external service integrations
+- Workflow and process changes
+
+### 5. Update Documentation
+
+Update incrementally:
+
+- Preserve accurate technical information
+- Update version numbers precisely
+- Add new sections for major additions
+- Mark deprecated technologies
+
+### 6. Save and Verify
+
+- Suggest backup for major changes
+- Verify all versions are accurate
+
+## Technical Questions Template
+
+### 🔄 Version Updates & Dependencies
+
+**1. Which major dependencies have been updated?**
+
+Review your recent dependency changes:
+
+a) **Framework upgrades** (Next.js, React, etc.) with breaking changes  
+b) **Tool updates** (TypeScript, ESLint, etc.) requiring config changes  
+c) **New dependencies** added for features or development  
+d) **Removed packages** that are no longer needed  
+e) **All of the above** - Major technical overhaul
+
+**2. Have you changed your package manager or Node version?**
+
+a) **Same setup** - No changes to tooling  
+b) **Node upgrade** - Updated Node.js version  
+c) **Package manager switch** - Changed from npm/yarn/pnpm  
+d) **Monorepo adoption** - Moved to workspace setup
+
+### 🏗️ Infrastructure Evolution
+
+**3. Have your deployment or hosting arrangements changed?**
+
+Current deployment is documented as: [show from existing doc]
+
+a) **Same platform** - Just configuration updates  
+b) **Platform migration** - Moved to different provider  
+c) **Architecture change** - Serverless, containers, etc.  
+d) **Multi-region** - Expanded geographic deployment
+
+**4. Database or storage changes?**
+
+a) **Version upgrade** - Same DB, newer version  
+b) **Migration** - Switched database systems  
+c) **New caching** - Added Redis, Memcached, etc.  
+d) **Storage addition** - New file storage, CDN  
+e) **No changes** - Same setup as before
+
+### 🛠️ Development Workflow Updates
+
+**5. New development tools or practices?**
+
+Select all that apply:
+
+- [ ] New testing framework or strategy
+- [ ] Added code quality tools (linters, formatters)
+- [ ] CI/CD pipeline changes
+- [ ] Docker/containerization adoption
+- [ ] New build tools or bundlers
+- [ ] Performance monitoring tools
+
+**6. External service integrations?**
+
+Have you added or changed:
+
+a) **Payment processing** - New or updated provider  
+b) **Authentication** - Different auth service  
+c) **Email/SMS** - Communication service changes  
+d) **Monitoring** - New error tracking or analytics  
+e) **APIs** - Additional third-party integrations  
+f) **None** - Same external services
+
+### 🔐 Security & Compliance
+
+**7. Security tool adoption?**
+
+- [ ] Vulnerability scanning (Snyk, etc.)
+- [ ] Secret management changes
+- [ ] New authentication methods
+- [ ] Compliance tools (GDPR, etc.)
+- [ ] Security headers/policies
+- [ ] None of the above
+
+## Update Strategy
+
+### Version Precision
+
+```typescript
+// ❌ Outdated
+"next": "^13.0.0"
+
+// ✅ Current and precise
+"next": "14.2.5"
+```
+
+### Configuration Updates
+
+- Update all config examples to match current files
+- Include new configuration options
+- Remove deprecated settings
+- Add migration notes for breaking changes
+
+### New Technology Sections
+
+When adding major new tools:
+
+```markdown
+### [New Tool Category]
+
+**Tool:** [Name] [Version]
+**Purpose:** [Why it was adopted]
+**Configuration:** [Key settings]
+**Integration:** [How it connects with other tools]
+```
+
+## Document Update Areas
+
+### Always Check:
+
+1. **package.json changes**
+
+   ```bash
+   # Compare all dependencies
+   # Note version changes
+   # Identify new packages
+   ```
+
+2. **Configuration files**
+
+   - tsconfig.json updates
+   - New .config files
+   - Build tool configurations
+   - Linting rule changes
+
+3. **Development scripts**
+
+   - New npm/pnpm scripts
+   - Changed command purposes
+   - Removed scripts
+
+4. **Infrastructure files**
+   - Dockerfile changes
+   - CI/CD workflows
+   - Deployment configs
+   - Environment examples
+
+### Conditional Updates:
+
+- **Architecture:** Only if fundamental changes
+- **Conventions:** Only if standards changed
+
+## Execution Steps
+
+### 1. Start with Analysis
+
+```bash
+# Check current dependencies vs documented
+diff <(jq -r '.dependencies | keys[]' package.json | sort) \
+     <(grep -E '^\*\*.*:' .claude/rules/2-tech-stack.mdc | cut -d: -f1 | sed 's/\*//g' | sort)
+
+# Review recent dependency commits
+git log --oneline --grep="dep" --since="30 days ago"
+
+# Check for new config files
+find . -name "*.config.*" -newer .claude/rules/2-tech-stack.mdc 2>/dev/null
+```
+
+**Think deeply about:** "What technical decisions drove these changes? How do version updates affect the overall architecture? What new capabilities do these tools enable?"
+
+### 2. Interactive Q&A
+
+- Present technical questions clearly
+- Include current state from documentation
+- Wait for detailed responses
+
+### 3. Update Documentation
+
+Follow incremental approach:
+
+```markdown
+<!-- Version update example -->
+
+**Before:** React 18.2.0
+**After:** React 18.3.1 - Includes new compiler optimizations
+
+<!-- New tool example -->
+
+### Code Quality Tools
+
+**New Addition:**
+
+- **Biome:** 1.8.3 - Replaced ESLint and Prettier
+  - Faster performance (10x)
+  - Single configuration file
+  - Built-in formatting
+```
+
+### 4. Save and Backup
+
+```bash
+# Optional backup
+cp .claude/rules/2-tech-stack.mdc .claude/rules/2-tech-stack.backup.md
+
+# Save updated document
+# Overwrite .claude/rules/2-tech-stack.mdc
+```
+
+## Key Principles
+
+### DO:
+
+- **Exact Versions:** Use precise version numbers from lock files
+- **Config Accuracy:** Match actual configuration files
+- **Change Rationale:** Explain why tools were adopted/changed
+- **Migration Notes:** Document breaking changes and updates
+- **Performance Impact:** Note improvements or concerns
+
+### DON'T:
+
+- **Generic Updates:** Avoid vague version ranges
+- **Assumption:** Verify every technical detail
+- **Old Information:** Remove outdated configurations
+- **Wishful Documentation:** Only document what exists
+- **Sensitive Data:** Never include secrets or keys
+
+## Output
+
+- **Format:** Markdown (`.mdc`)
+- **Location:** `.claude/rules/`
+- **Filename:** `2-tech-stack.mdc` (overwrites)
+- **Backup:** Suggest for major changes
+
+## Final Checklist
+
+1. ✅ Read existing 2-tech-stack.mdc completely
+2. ✅ Analyze all dependency changes
+3. ✅ Check configuration file updates
+4. ✅ Review infrastructure changes
+5. ✅ Ask targeted technical questions
+6. ✅ Update with exact versions
+7. ✅ Include configuration examples
+8. ✅ Suggest backup if major changes
+9. ✅ Verify technical accuracy