appiq-solution 1.2.0 → 1.3.1

package/SuperClaude/.claude/commands/document.md

@@ -0,0 +1,99 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Create comprehensive docs for code, API, or system specified in $ARGUMENTS.
+
+Flags:
+- --api: Generate API docs | --user: Generate user-friendly guides
+- --ultracompressed, --uc: Generate docs w/ ~70% fewer tokens using telegram-style
+
+--api flag:
+- Document all endpoints w/ examples | Include request/response formats
+- Specify auth requirements | Document error codes & meanings | Add rate limiting info | Provide code samples→multiple languages
+
+--user flag:
+- Create user-friendly guides | Include step-by-step tutorials | Add screenshots or diagrams
+- Write FAQ section | Include troubleshooting guide | Provide real-world examples
+
+Documentation types:
+
+README Documentation:
+- Project overview and purpose
+- Installation instructions
+- Quick start guide
+- Configuration options
+- Basic usage examples
+- Contributing guidelines
+
+Architecture Documentation:
+- System design overview
+- Component relationships
+- Data flow diagrams
+- Technology choices rationale
+- Scalability considerations
+- Security architecture
+
+API Documentation:
+- Endpoint descriptions
+- HTTP methods and status codes
+- Request/response schemas
+- Authentication methods
+- Example requests with curl/code
+- Webhook documentation
+- WebSocket events (if applicable)
+
+User Guides:
+- Getting started tutorial
+- Feature walkthroughs
+- Best practices guide
+- Common use cases
+- Integration guides
+- Migration guides
+
+Developer Documentation:
+- Code structure overview
+- Development setup
+- Testing guidelines
+- Deployment process
+- Debugging tips
+- Performance optimization
+
+Documentation standards:
+- Use clear, concise language
+- Include practical examples
+- Add visual aids where helpful
+- Keep information current
+- Make it searchable
+- Version-specific when needed
+- Test all code examples
+
+When --ultracompressed flag is present:
+- Apply shared/ultracompressed.yml rules
+- Generate legend at doc start
+- Remove articles, conjunctions, fillers
+- Use symbols: →&@+- w/ w/o
+- Use abbreviations: cfg fn impl req resp
+- Headings <20 chars, sentences <50 chars
+- Format: YAML>JSON>prose, tables>lists>paragraphs
+- Target ~70% token reduction
+
+Structure guidelines:
+- Logical organization
+- Progressive disclosure
+- Cross-references
+- Glossary for terms
+- Index for quick lookup
+- Change log maintenance
+
+Documentation Output:
+- API documentation: `/docs/api/`
+- User guides: `/docs/guides/`
+- Architecture docs: `/docs/architecture/`
+- Developer docs: `/docs/development/`
+- README files: `/docs/README.md` (main), subdirectory READMEs as needed
+- Ensure directory exists: `mkdir -p /docs/[category]/`
+- Include location in output: "📚 Documentation created: [path]"
+- Update `/docs/index.md` with new documentation links
+
+Deliverables: Complete documentation matching the specified type, working code examples, visual aids or diagrams as needed, and quick reference guide.

package/SuperClaude/.claude/commands/estimate.md

@@ -0,0 +1,69 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Provide comprehensive time & complexity estimates for task in $ARGUMENTS.
+
+Thinking flags (optional):
+- --think→multi-component estimation w/ deps
+- --think-hard→complex project estimation w/ risk analysis
+- --ultrathink→enterprise-scale estimation w/ full uncertainty modeling
+
+Examples:
+- `/user:estimate --detailed --think` - Detailed breakdown w/ dependency analysis
+- `/user:estimate --worst-case --think-hard` - Risk-based estimation w/ comprehensive scenarios
+- `/user:estimate "migrate to microservices" --ultrathink` - Complex architectural estimation
+
+Relevant factors:
+
+Time components:
+- Dev time→impl | Code review & feedback cycles | Testing (unit, integration, E2E)
+- Deployment & verification | Docs updates
+
+Complexity multipliers:
+- New feature from scratch: 1x baseline | Refactoring existing: 1.5x (understanding + changing)
+- Working w/ legacy: 2x (constraints + unknowns) | Cross-team deps: 1.5x (coordination overhead)
+
+Uncertainty factors:
+- Clear requirements, known tech: ±10%
+- Some unknowns, new patterns: ±25%
+- Significant unknowns, research needed: ±50%
+- Completely new territory: ±100%
+
+Estimation workflow:
+1. Break down task into subtasks
+2. Estimate each subtask individually
+3. Apply complexity multipliers
+4. Add appropriate uncertainty buffer
+5. Provide a realistic range, not a single number
+
+Formula: Base time × Complexity × Uncertainty = Time range
+
+Include in estimates:
+- Best case scenario (everything goes smoothly)
+- Realistic case (normal friction and discoveries)
+- Worst case scenario (significant obstacles)
+
+## Additional Considerations
+
+Context factors:
+- Developer experience level with the codebase
+- Availability of documentation and examples
+- Required coordination with other teams
+- Potential blockers or dependencies
+
+Research requirements for estimation:
+- Technology patterns → Research implementation complexity via C7 and official docs
+- Architecture patterns → WebSearch for similar project timelines and case studies
+- Team velocity → Check historical data and industry benchmarks
+- Risk assessment → Must verify common pitfalls and mitigation strategies
+- Never estimate based on gut feeling - always research comparable scenarios
+- All estimates must cite sources: // Source: [estimation data reference]
+
+Report Output:
+- Estimate summaries: `.claudedocs/summaries/estimate-<timestamp>.md`
+- Risk assessments: `.claudedocs/reports/risk-analysis-<timestamp>.md`
+- Ensure directory exists: `mkdir -p .claudedocs/summaries/ .claudedocs/reports/`
+- Include report location in output: "📄 Estimate saved to: [path]"
+
+Deliverables: Time estimate range (min-max), complexity assessment, required resources, key assumptions, risk analysis, and potential blockers that could affect the estimate.

package/SuperClaude/.claude/commands/explain.md

@@ -0,0 +1,85 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Provide comprehensive explanations of concepts, code, or systems in $ARGUMENTS.
+
+Thinking flags (optional):
+- --think→multi-concept explanation w/ connections
+- --think-hard→complex system explanations w/ deep analysis
+- --ultrathink→comprehensive knowledge synthesis & teaching
+
+MCP flags (optional):
+- --c7→fetch official lib/framework docs | --seq→step-by-step concept breakdown
+- --no-mcp→explain using only codebase context
+
+Doc flags:
+- --ultracompressed or --uc→7 0% token reduction in explanations
+
+Examples:
+- `/user:explain --c7 "React hooks" --think` - React hooks w/ contextual connections
+- `/user:explain --seq "OAuth flow" --think-hard` - Deep OAuth analysis w/ security implications
+- `/user:explain --depth advanced --c7 --ultrathink` - Comprehensive system explanation
+
+--depth flag levels:
+- ELI5: Simple analogies, avoid jargon, focus→concepts
+- Beginner: Cover basics, step-by-step guidance, simple examples
+- Intermediate: Tech details, best practices, common patterns
+- Expert: Deep impl details, edge cases, perf considerations
+
+When --visual flag is present:
+- Create diagrams using Mermaid syntax
+- Use ASCII art for simple visualizations
+- Include flowcharts for processes
+- Add sequence diagrams for interactions
+
+Structure the explanation:
+1. Start with a high-level overview
+2. Break down into logical components
+3. Explain each component with appropriate depth
+4. Show relationships and interactions
+5. Provide concrete examples
+
+Include relevant formats:
+- Code examples that can be run and tested
+- Comparison tables for alternatives
+- Pros and cons lists for decisions
+- Links to authoritative resources
+
+For technical concepts:
+- Explain the "what" before the "how"
+- Connect to familiar concepts when possible
+- Build understanding incrementally
+- Address common misconceptions
+
+For code explanations:
+- Walk through logic step by step
+- Explain design decisions
+- Highlight important patterns
+- Point out potential gotchas
+
+## UltraCompressed Mode
+
+When --ultracompressed flag is present:
+- Apply shared/ultracompressed.yml rules
+- Generate legend for symbols/abbreviations used
+- Compress explanations to ~30% of normal size
+- Use telegram-style: remove articles, use symbols
+- Format: lists>paragraphs, tables>prose
+- Example: "fn takes 3 params→bool" instead of "The function takes three parameters and returns a boolean value"
+
+Research requirements for explanations:
+- Technical concepts → C7 documentation for authoritative explanations and examples
+- Framework patterns → Must verify with official guides and documentation
+- Best practices → WebSearch for current industry standards and expert opinions
+- Code examples → Research working patterns from official documentation
+- Never explain without verification - always cite authoritative sources
+- All explanations must include sources: // Source: [documentation reference]
+
+Report Output:
+- Explanation summaries: `.claudedocs/summaries/explanation-<topic>-<timestamp>.md`
+- Learning resources: `.claudedocs/reports/learning-resources-<timestamp>.md`
+- Ensure directory exists: `mkdir -p .claudedocs/summaries/ .claudedocs/reports/`
+- Include report location in output: "📚 Explanation saved to: [path]"
+
+Deliverables: Clear explanation at the appropriate depth level, working examples, visual aids if requested, curated resources for further learning, and comprehensive source references.

package/SuperClaude/.claude/commands/git.md

@@ -0,0 +1,47 @@
+## Legend
+| Symbol | Meaning | | Abbrev | Meaning |
+|--------|---------|---|--------|---------|
+| → | leads to | | repo | repository |
+| & | and/with | | sync | synchronize |
+| w/ | with | | chkpt | checkpoint |
+
+@include shared/command-templates.yml#Command_Header
+
+Manage git workflows for repo in $ARGUMENTS.
+
+@see shared/thinking-modes.yml ∀ thinking flags
+
+Examples:
+- `/user:git --status` - Comprehensive repo status
+- `/user:git --commit "Add feature"` - Create commit
+- `/user:git --branch feature/ui` - Create & switch→branch  
+- `/user:git --sync` - Fetch, pull & push
+- `/user:git --merge develop --think` - Merge w/ conflict analysis
+
+Git operations:
+
+**--status:** Working tree status | Current branch & upstream | Stashed changes | Recent commits (5) | Unpushed commits | Remote status
+
+**--commit:** Stage files (-a→all) | Generate message if missing | Follow conventions | Verify tests pass | Create chkpt | GPG sign if configured
+
+**--branch:** Create from HEAD/base | Switch to existing | --delete→remove merged | --list→show all w/ descriptions | Auto-track remote | Protect current/main
+
+**--sync:** Fetch all remotes | Pull w/ rebase | Push to tracked remote | Handle auth | Resolve conflicts | Update submodules
+
+**--merge:** Fetch target branch | Check conflicts | Create chkpt | Use merge strategy | Handle conflicts interactively | Verify results
+
+**--stash:** Save w/ message | List w/ timestamps | Apply/pop specific | Drop old/unnecessary | Handle conflicts
+
+**--history:** Commit log w/ formats | Filter by author/date/path | Branch topology | Search messages | File change stats
+
+**--checkpoint:** Tagged state snapshot | Descriptive message | Store in manifest | Enable rollback
+
+**--rollback:** List available chkpts | Verify safety | Pre-rollback chkpt | Execute rollback | Verify state
+
+@see shared/git-workflow.yml ∀ best practices
+@see shared/checkpoint.yml ∀ checkpoint system
+@see shared/error-handling.yml ∀ safety checks
+
+Workflow: Check status→Create chkpt→Execute→Verify→Sync
+
+Deliverables: Updated repo state, commit history, branch mgmt, remote sync.

package/SuperClaude/.claude/commands/improve.md

@@ -0,0 +1,162 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Improve code, perf, or quality of system specified in $ARGUMENTS.
+
+Improvement focus w/ flags:
+
+--quality flag:
+- Improve code structure & maintainability
+- w/ --solid: Apply SOLID principles systematically | w/ --refactor: Clean code refactoring
+- w/ --metrics: Generate quality metrics report
+
+--perf flag:
+- Optimize system perf | Analyze bottlenecks & resource usage
+- Impl caching & async ops | Improve algorithm complexity
+
+--iterate flag:
+- Iteratively improve until threshold reached | w/ --threshold: Set target % (default 85%)
+- Measure progress after each iteration | Stop at diminishing returns
+
+--watch flag:
+- Continuous improvement monitoring | Auto-apply safe optimizations
+- Real-time perf tracking | Automated quality maintenance
+
+When --interactive flag is present:
+- Guided improvement process
+- User choice on optimization strategies
+- Step-by-step quality enhancement
+- Interactive threshold adjustment
+
+## Code Quality Mode (--quality)
+
+SOLID Principles application:
+- **Single Responsibility**: One class, one purpose
+- **Open/Closed**: Extensible but not modifiable
+- **Liskov Substitution**: Subtypes must be substitutable
+- **Interface Segregation**: Specific over general interfaces
+- **Dependency Inversion**: Depend on abstractions
+
+Refactoring techniques:
+- Extract method/class for complex logic
+- Inline unnecessary abstractions
+- Rename for clarity and consistency
+- Move code to appropriate modules
+- Remove duplication (DRY principle)
+- Simplify conditionals and loops
+- Reduce coupling, increase cohesion
+
+Quality metrics to track:
+- Cyclomatic complexity (target < 5)
+- Method length (target < 20 lines)
+- Class cohesion and coupling
+- Code duplication percentage
+- Test coverage (target > 80%)
+- Documentation completeness
+
+Clean code principles:
+- Meaningful, self-documenting names
+- Functions do one thing well
+- Consistent coding style
+- Proper error handling
+- No magic numbers/strings
+- Comments explain why, not what
+
+## Performance Mode (--performance)
+
+Performance optimization areas:
+
+**Code optimization**:
+- Algorithm complexity reduction (O(n²) → O(n log n))
+- Efficient data structures
+- Caching frequently accessed data
+- Lazy loading and pagination
+- Async/parallel processing
+- Memory usage optimization
+
+**Database optimization**:
+- Query optimization and indexing
+- N+1 query elimination
+- Connection pooling
+- Batch operations
+- Denormalization where appropriate
+- Query result caching
+
+**Frontend optimization**:
+- Bundle size reduction
+- Code splitting and lazy loading
+- Image and asset optimization
+- Render performance improvements
+- Service worker caching
+- Reducing re-renders
+
+**System optimization**:
+- Load balancing strategies
+- CDN implementation
+- Compression (gzip/brotli)
+- HTTP/2 and caching headers
+- Resource pooling
+- Microservice optimization
+
+## Iterative Mode (--iterate)
+
+Iteration process:
+1. **Baseline Measurement**
+   - Current performance metrics
+   - Quality scores
+   - Coverage percentage
+   - User satisfaction
+
+2. **Targeted Improvements**
+   - Focus on highest impact areas
+   - Apply 80/20 rule
+   - Make incremental changes
+   - Maintain working state
+
+3. **Progress Tracking**
+   - Measure after each change
+   - Document improvements
+   - Calculate ROI of changes
+   - Adjust strategy as needed
+
+4. **Completion Criteria**
+   - Reach target threshold
+   - Diminishing returns detected
+   - Time/budget constraints
+   - "Good enough" achieved
+
+Focus areas by iteration type:
+- **Quality**: Complexity, duplication, coverage
+- **Performance**: Response time, throughput, resources
+- **User Experience**: Load time, responsiveness, errors
+- **Maintainability**: Documentation, tests, structure
+
+## Best Practices
+
+General improvement approach:
+1. Measure before changing
+2. Focus on bottlenecks first
+3. Make one change at a time
+4. Verify improvements
+5. Document changes made
+6. Consider trade-offs
+
+Avoid common pitfalls:
+- Premature optimization
+- Over-engineering
+- Breaking changes
+- Ignoring tests
+- Gold-plating
+
+Balance considerations:
+- Performance vs readability
+- Flexibility vs simplicity
+- Speed vs correctness
+- Present vs future needs
+
+@include shared/command-templates.yml#Research_Requirements
+
+@include shared/command-templates.yml#Report_Output
+
+@include shared/constants.yml#Success_Messages

package/SuperClaude/.claude/commands/index.md

@@ -0,0 +1,159 @@
+# SuperClaude Commands Index
+
+@include shared/constants.yml#Process_Symbols
+
+## Command Usage
+All commands use `/user:` prefix. Examples:
+- `/user:build --init` | `/user:analyze --code` | `/user:deploy --env prod`
+
+## Universal Flags (All Commands)
+
+**Planning & Thinking:**
+- `--plan` - Show execution plan before running
+- `--think` - Standard analysis mode (multi-file context, ~4K tokens)
+- `--think-hard` - Deep analysis mode (architecture level, ~10K tokens)
+- `--ultrathink` - Critical analysis mode (system-wide, ~32K tokens)
+
+**Documentation Control:**
+- `--ultracompressed` / `--uc` - ~70% token reduction mode w/ telegram-style formatting
+
+**MCP Server Control:**
+- `--c7` / `--no-c7` - Enable/disable Context7 docs lookup
+- `--seq` / `--no-seq` - Enable/disable Sequential thinking analysis
+- `--magic` / `--no-magic` - Enable/disable Magic UI component builder
+- `--pup` / `--no-pup` - Enable/disable Puppeteer browser automation
+- `--all-mcp` - Enable all MCP servers→maximum capability
+- `--no-mcp` - Disable all MCP servers (native tools only)
+
+## Development Commands (3)
+| Command | Purpose | Key Flags |
+|---------|---------|-----------|
+| /user:build | Universal project builder | --init --feature --react --api --tdd |
+| /user:dev-setup | Dev environment & CI/CD | --install --ci --monitor |
+| /user:test | Testing framework | --coverage --watch --e2e |
+
+## Analysis & Improvement Commands (4)
+| Command | Purpose | Key Flags |
+|---------|---------|-----------|
+| /user:analyze | Multi-dimensional analysis | --code --architecture --profile --security |
+| /user:troubleshoot | Debug and fix issues | --investigate --fix --five-whys --prod |
+| /user:improve | Enhance code/performance | --quality --performance --iterate --threshold |
+| /user:explain | Deep explanations | --depth --visual --examples |
+
+## Operations Commands (6)
+| Command | Purpose | Key Flags |
+|---------|---------|-----------|
+| /user:deploy | Application deployment | --env --rollback |
+| /user:migrate | Database/code migration | --dry-run --rollback |
+| /user:scan | Security & validation | --validate --security --owasp --deps |
+| /user:estimate | Time/complexity predictions | --detailed --worst-case |
+| /user:cleanup | Project cleanup & maintenance | --code --files --deps --git --all --dry-run |
+| /user:git | Git workflow management | --status --commit --branch --sync --merge --stash --history --checkpoint --rollback |
+
+## Design & Architecture Commands (1)
+| Command | Purpose | Key Flags |
+|---------|---------|-----------|
+| /user:design | System design | --api --ddd --prd --openapi --graphql --bounded-context |
+
+## Workflow Commands (2)
+| Command | Purpose | Key Flags |
+|---------|---------|-----------|
+| /user:spawn | Spawn focused agent | --task |
+| /user:document | Documentation creation | --api --user |
+
+## System Commands (1)
+| Command | Purpose | Key Flags |
+|---------|---------|-----------|
+| /user:load | Load project context | --depth |
+
+## Quick Reference & Workflow Examples
+
+### Common Development Flows
+```yaml
+Project Setup:
+  New Project: load → dev-setup --install → build --init → test --coverage
+  Existing: load --depth deep → analyze --architecture → design
+  
+Full Development Cycle:
+  Feature: load → analyze → design --api → build --tdd → test --e2e → deploy
+  Bug Fix: troubleshoot --investigate → troubleshoot --fix → test → git --commit
+  Refactor: analyze --code → improve --quality → test --coverage → git --commit
+  
+Quality Workflows:
+  Code Review: analyze --code --think → improve --quality → scan --validate
+  Performance: analyze --profile → improve --performance --iterate → test
+  Security: scan --security --owasp → improve --quality → scan --validate
+  
+Maintenance:
+  Cleanup: cleanup --all --dry-run → cleanup --all → analyze → test
+  Update: migrate --dry-run → migrate → test --coverage → deploy --env staging
+  Monitor: analyze --performance --watch → improve --threshold 90%
+```
+
+### Advanced Flag Combinations
+```yaml
+Power User Patterns:
+  Deep Analysis: analyze --architecture --seq --think-hard
+  UI Development: build --react --magic --pup --watch
+  Production Deploy: scan --validate --seq → deploy --env prod --think-hard
+  Emergency Debug: troubleshoot --prod --ultrathink --seq
+  
+Research & Learning:
+  Library Study: explain --c7 --seq --depth expert "React hooks"
+  Architecture: design --ddd --seq --think-hard → document --api
+  Performance: analyze --profile --seq → improve --iterate --threshold 95%
+  
+Token Optimization:
+  Compressed Docs: document --uc → explain --uc --c7
+  Efficient Analysis: analyze --uc --no-mcp → improve --uc
+  Rapid Workflow: build --uc → test --uc → deploy --uc
+```
+
+### Safety & Best Practices
+```yaml
+Pre-Deployment Safety:
+  Full Gate: test --coverage → scan --security → scan --validate → deploy
+  Staged: deploy --env staging → test --e2e → deploy --env prod --plan
+  Rollback Ready: git --checkpoint → deploy → (if issues) deploy --rollback
+  
+Development Safety:
+  Clean First: cleanup --code → build → test → commit
+  Quality Gate: analyze → improve --quality → test → commit
+  Secure: scan --security → fix issues → scan --validate
+  
+Planning for Complex Operations:
+  Architecture: design --api --ddd --plan --think-hard
+  Migration: migrate --dry-run → migrate --plan → verify
+  Cleanup: cleanup --all --dry-run → review → cleanup --all
+```
+
+## Shared Resources (37 files)
+- `ambiguity-check.yml`: Ambiguity detection & resolution
+- `audit.yml`: Audit configurations & logging
+- `checkpoint.yml`: Checkpoint management & rollback
+- `cleanup-patterns.yml`: Cleanup safety rules & patterns
+- `command-memory.yml`: Enhanced command result sharing & context management
+- `command-templates.yml`: Token-optimized reusable command patterns
+- `constants.yml`: Universal constants & shared values
+- `documentation-dirs.yml`: Documentation directory standards
+- `error-handling.yml`: Error handling & resilience patterns
+- `evidence.yml`: Evidence tracking & validation
+- `execution-lifecycle.yml`: Command execution flow & lifecycle management
+- `git-workflow.yml`: Git integration patterns
+- `implementation.yml`: Implementation hooks & behaviors
+- `loading-config.yml`: Token optimization & lazy loading
+- `mcp-flags.yml`: Enhanced MCP server control via flags
+- `patterns.yml`: Enhanced common workflows & command integration patterns
+- `performance.yml`: Performance monitoring & metrics
+- `planning-mode.yml`: Risk assessment & planning configuration
+- `research-first.yml`: Mandatory research & documentation requirements
+- `severity-levels.yml`: Severity classification & escalation paths
+- `task-system.yml`: Comprehensive task management & workflow system
+- `thinking-modes.yml`: Thinking depth configuration & flags
+- `ultracompressed.yml`: ~70% token reduction documentation mode
+- `user-experience.yml`: User interface & interaction patterns (NEW)
+- `validation.yml`: Validation rules & standards
+- `workflow-chains.yml`: Command chaining & orchestration patterns (NEW)
+
+---
+*SuperClaude v4.0.0 - 18 commands with comprehensive configuration framework*

package/SuperClaude/.claude/commands/load.md

@@ -0,0 +1,65 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Load & analyze project context in $ARGUMENTS→build comprehensive understanding.
+
+--depth flag:
+- shallow: Quick overview→project structure & purpose
+- normal: Standard analysis→main files & architecture
+- deep: Comprehensive analysis→entire codebase
+
+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
+
+Files→analyze:
+
+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
+
+Source structure:
+- Main entry points | Directory org | Module boundaries | Shared components/utilities
+- Test structure
+
+Version control:
+- Current git status
+- Recent commit history
+- Branch structure
+- Uncommitted changes
+
+Depth-specific analysis:
+
+Shallow depth:
+- Project purpose and goals
+- Main technologies used
+- High-level architecture
+- Key dependencies
+- Quick start information
+
+Normal depth:
+- Detailed file structure
+- Main components and modules
+- API endpoints or routes
+- Database schema
+- Testing approach
+- Development workflow
+
+Deep depth:
+- Complete code analysis
+- All file relationships
+- Detailed dependency graph
+- Performance bottlenecks
+- Security considerations
+- Technical debt areas
+- Optimization opportunities
+
+Build mental model including:
+- How components interact
+- Data flow through system
+- External integrations
+- Deployment architecture
+- Development patterns used
+
+Deliverables: Comprehensive project understanding summary, identified next steps or recommendations, key areas requiring attention, and quick reference guide for project navigation.