Clean up references to deleted scripts and pattern system

- Removed references to validate-references.sh from YAML files
- Removed expand-references.sh from settings.local.json
- Cleaned up @pattern/@flags references from shared files
- Updated documentation to reflect current no-code implementation
- Simplified reference-index.yml to remove @include patterns

This cleanup removes confusion from the abandoned pattern reference
system while maintaining all functionality.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
NomenAK
2025-06-24 21:24:14 +02:00
parent 84ad5b60d1
commit 9c3608a783
81 changed files with 8213 additions and 4646 deletions

View File

@@ -1,65 +1,256 @@
@include shared/constants.yml#Process_Symbols
# /load - Load and analyze project context
@include shared/command-templates.yml#Universal_Flags
## Legend
| Symbol | Meaning | | Abbrev | Meaning |
|--------|---------|---|--------|---------|
| → | leads to | | cfg | configuration |
| & | and/with | | impl | implementation |
| w/ | with | | perf | performance |
| @ | at/located | | ops | operations |
| > | greater than | | val | validation |
| ∀ | for all/every | | req | requirements |
| ∃ | exists/there is | | deps | dependencies |
| ∴ | therefore | | env | environment |
| ∵ | because | | db | database |
| ≡ | equivalent | | api | interface |
| ≈ | approximately | | docs | documentation |
| 📁 | directory/path | | std | standard |
| 🔢 | number/count | | def | default |
| 📝 | text/string | | ctx | context |
| ⚙ | setting/config | | err | error |
| 🎛 | control/flags | | exec | execution |
| 🔧 | configuration | | qual | quality |
| 📋 | group/category | | rec | recovery |
| 🚨 | critical/urgent | | sev | severity |
| ⚠ | warning/caution | | resp | response |
| 🔄 | retry/recovery | | esc | escalation |
| ✅ | success/fixed | | tok | token |
| ❌ | failure/error | | opt | optimization |
| | information | | UX | user experience |
| ⚡ | fast/quick | | UI | user interface |
| 🐌 | slow/delayed | | C | critical |
| ✨ | complete/done | | H | high |
| 📖 | read operation | | M | medium |
| ✏ | edit operation | | L | low |
| 🗑 | delete operation | | |
Load & analyze project context in $ARGUMENTS→build comprehensive understanding.
## Purpose
Load and analyze project context in $ARGUMENTS to build comprehensive understanding of codebase structure, architecture, and patterns.
--depth flag:
- shallow: Quick overview→project structure & purpose
- normal: Standard analysis→main files & architecture
- deep: Comprehensive analysis→entire codebase
## Syntax
`/load [flags] [path]`
Loading process:
1. Scan project structure & directory layout 2. Read key cfg & docs files
3. Analyze code architecture & patterns 4. Build mental model→project org 5. ID techs & deps
## Universal Flags
--plan: "Show execution plan before running"
--uc: "UltraCompressed mode (~70% token reduction)"
--ultracompressed: "Alias for --uc"
--think: "Multi-file analysis w/ context (4K tokens)"
--think-hard: "Deep architectural analysis (10K tokens)"
--ultrathink: "Critical system redesign (32K tokens)"
--c7: "Enable Context7→library documentation lookup"
--seq: "Enable Sequential→complex analysis & thinking"
--magic: "Enable Magic→UI component generation"
--pup: "Enable Puppeteer→browser automation & testing"
--all-mcp: "Enable all MCP servers"
--no-mcp: "Disable all MCP servers (native tools only)"
--no-c7: "Disable Context7 specifically"
--no-seq: "Disable Sequential thinking specifically"
--no-magic: "Disable Magic UI builder specifically"
--no-pup: "Disable Puppeteer specifically"
Files→analyze:
## Command-Specific Flags
Essential:
- README.md→project overview | package.json/requirements.txt/go.mod→deps
- Cfg files (.env.example, cfg/*) | Build cfg (webpack, vite, etc.) | CI/CD cfg files
**Analysis Depth:**
- `--depth shallow`: Quick overview of project structure and purpose
- `--depth normal`: Standard analysis of main files and architecture (default)
- `--depth deep`: Comprehensive analysis of entire codebase
Source structure:
- Main entry points | Directory org | Module boundaries | Shared components/utilities
- Test structure
**Analysis Focus:**
- `--architecture`: Focus on system design and component relationships
- `--dependencies`: Analyze dependency graph and package relationships
- `--security`: Include security considerations and potential issues
- `--performance`: Identify performance patterns and potential bottlenecks
- `--testing`: Analyze testing approach and coverage patterns
Version control:
- Current git status
- Recent commit history
- Branch structure
- Uncommitted changes
**Output Control:**
- `--summary`: Generate concise project overview
- `--detailed`: Include comprehensive analysis details
- `--recommendations`: Provide actionable next steps and improvements
Depth-specific analysis:
## Examples
- `/load --depth shallow` → Quick project overview
- `/load --depth deep --architecture` → Comprehensive architectural analysis
- `/load --dependencies --security` → Focus on deps and security
- `/load --performance --testing --detailed` → Performance and testing analysis
- `/load --summary --recommendations` → Overview with actionable insights
Shallow depth:
- Project purpose and goals
- Main technologies used
- High-level architecture
- Key dependencies
- Quick start information
## Loading Process
Normal depth:
- Detailed file structure
- Main components and modules
- API endpoints or routes
- Database schema
- Testing approach
- Development workflow
**1. Project Structure Scan:**
- Directory layout and organization
- File types and distribution
- Module boundaries and hierarchies
- Entry points and main components
Deep depth:
- Complete code analysis
- All file relationships
- Detailed dependency graph
- Performance bottlenecks
- Security considerations
- Technical debt areas
- Optimization opportunities
**2. Configuration Analysis:**
- Package manifests (package.json, requirements.txt, go.mod)
- Build configurations (webpack, vite, rollup)
- Environment and deployment configs
- CI/CD pipeline definitions
Build mental model including:
- How components interact
- Data flow through system
- External integrations
- Deployment architecture
- Development patterns used
**3. Code Architecture Review:**
- Design patterns and architectural style
- Component relationships and dependencies
- Data flow and state management
- API structure and endpoints
Deliverables: Comprehensive project understanding summary, identified next steps or recommendations, key areas requiring attention, and quick reference guide for project navigation.
**4. Development Environment:**
- Git repository status and history
- Development workflow patterns
- Testing framework and approach
- Documentation quality and coverage
**5. Technology Stack Identification:**
- Frontend and backend technologies
- Database and data storage solutions
- Third-party integrations and services
- Development and deployment tools
## Analysis Depth Levels
**Shallow Depth:**
- Project purpose and business goals
- Primary technologies and frameworks
- High-level architecture overview
- Key dependencies and integrations
- Quick start and setup information
- Development team structure clues
**Normal Depth:**
- Detailed file and directory structure
- Main components and their responsibilities
- API endpoints, routes, and data models
- Database schema and relationships
- Testing strategy and coverage areas
- Development workflow and best practices
**Deep Depth:**
- Complete codebase analysis and mapping
- Detailed component interaction diagrams
- Comprehensive dependency relationships
- Performance characteristics and bottlenecks
- Security considerations and vulnerabilities
- Technical debt assessment
- Optimization opportunities and recommendations
## Essential Files Analysis
**Documentation:**
- README.md (project overview and setup)
- CONTRIBUTING.md (development guidelines)
- API documentation and specs
- Architecture decision records (ADRs)
**Configuration:**
- Package managers (package.json, yarn.lock, requirements.txt)
- Build tools (webpack.config.js, vite.config.ts)
- Environment configs (.env files, docker-compose.yml)
- CI/CD pipelines (.github/workflows, .gitlab-ci.yml)
**Source Code:**
- Entry points (main.js, app.py, index.html)
- Core modules and components
- Shared utilities and libraries
- Test files and test configurations
**Version Control:**
- Git history and commit patterns
- Branch strategy and naming conventions
- Recent changes and active development areas
- Contributor patterns and team structure
## Mental Model Construction
**System Understanding:**
- Component interaction patterns
- Data flow through the application
- External service integrations
- Deployment and infrastructure architecture
- User journey and experience flows
**Development Insights:**
- Code quality and consistency patterns
- Testing maturity and coverage
- Documentation completeness
- Development velocity indicators
- Technical debt and maintenance needs
## Deliverables
- **Project Overview**: Comprehensive understanding summary
- **Architecture Map**: System design and component relationships
- **Technology Inventory**: Complete stack and dependency analysis
- **Development Guide**: Quick reference for project navigation
- **Recommendations**: Next steps and improvement opportunities
- **Risk Assessment**: Potential issues and technical debt areas
## Output Locations
- **Analysis Reports**: `.claudedocs/summaries/project-analysis-{timestamp}.md`
- **Architecture Docs**: `.claudedocs/summaries/architecture-overview-{timestamp}.md`
- **Quick Reference**: `.claudedocs/summaries/project-guide-{timestamp}.md`
## Research Requirements
External_Library_Research:
- Identify library/framework mentioned
- Context7 lookup for official documentation
- Verify API patterns and examples
- Check version compatibility
- Document findings in implementation
Pattern_Research:
- Search existing codebase for similar patterns
- Magic component search if UI-related
- WebSearch for official documentation
- Validate approach with Sequential thinking
- Document pattern choice rationale
API_Integration_Research:
- Official documentation lookup
- Authentication requirements
- Rate limiting and error handling
- SDK availability and examples
- Integration testing approach
## Report Notifications
📄 Analysis report saved to: {path}
📊 Metrics updated: {path}
📋 Summary saved to: {path}
💾 Checkpoint created: {path}
📚 Documentation created: {path}
📁 Created directory: {path}
✅ {operation} completed successfully
❌ {operation} failed: {reason}
⚠ {operation} completed w/ warnings
## Integration Patterns
**Workflow Integration:**
- Load project context before major development work
- Refresh understanding after significant changes
- Share context with team members and new contributors
- Use as foundation for architecture decisions
**Command Chaining:**
- `load``analyze --architecture` for design review
- `load``scan --security` for security assessment
- `load``improve --quality` for refactoring planning
- `load``document --architecture` for documentation
## Troubleshooting
- **Large Codebases**: Use `--depth shallow` for initial overview
- **Complex Architecture**: Combine `--architecture --detailed` for comprehensive analysis
- **Performance Issues**: Include `--performance` flag for optimization insights
- **Security Concerns**: Add `--security` flag for vulnerability assessment
## Success Messages
✅ {operation} completed successfully
📝 Created: {file_path}
✏ Updated: {file_path}
✨ Task completed: {task_title}