appiq-solution 1.2.0 → 1.3.0

package/#Tools/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/#Tools/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/#Tools/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.

package/#Tools/SuperClaude/.claude/commands/migrate.md

@@ -0,0 +1,76 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Execute comprehensive DB or code migration based on specs in $ARGUMENTS.
+
+Thinking flags (optional):
+- --think→multi-system migration coordination
+- --think-hard→complex data transformation & rollback planning
+- --ultrathink→enterprise-scale migration w/ zero-downtime requirements
+
+Examples:
+- `/user:migrate --dry-run --think` - Migration preview w/ impact analysis
+- `/user:migrate --think-hard` - Complex migration w/ comprehensive safety planning
+- `/user:migrate --rollback --ultrathink` - Critical rollback w/ full system analysis
+
+Migration types:
+
+Schema migrations:
+- Create, alter, or drop tables | Add or modify indexes→perf
+- Update constraints & relationships | Manage DB versioning
+
+Data migrations:
+- Transform existing data→new format | Backfill missing or derived data
+- Clean up obsolete or orphaned records | Ensure data integrity throughout
+
+Code migrations:
+- Refactor→new patterns or arch
+- Update to new framework versions
+- Migrate between different technologies
+- Modernize legacy code
+
+Follow the safe migration workflow:
+1. Plan - Design migration strategy and rollback plan
+2. Backup - Create full backup of affected data/code
+3. Test - Run migration in test environment first
+4. Execute - Apply migration with transaction support
+5. Verify - Validate migration success and data integrity
+
+When --dry-run flag is present:
+- Preview all changes without executing
+- Show affected records/files count
+- Estimate migration duration
+- Identify potential issues
+
+When --rollback flag is present:
+- Revert to pre-migration state
+- Use transaction rollback when possible
+- Restore from backup if needed
+- Verify system stability
+
+## Safety Measures & Best Practices
+
+Safety measures:
+- Use database transactions for atomicity
+- Calculate checksums for data validation
+- Implement idempotent migrations
+- Test rollback procedure before execution
+- Monitor system during migration
+
+Research requirements for migration:
+- Database patterns → C7 documentation for database-specific migration patterns
+- Framework migrations → Must verify with official migration guides and best practices
+- Data transformation → Research ETL patterns and data integrity verification methods
+- Zero-downtime patterns → WebSearch for platform-specific blue-green migration strategies
+- Never migrate without tested rollback - always verify migration patterns
+- All migration scripts must cite sources: // Source: [migration guide reference]
+
+Report Output:
+- Migration logs: `.claudedocs/reports/migration-<timestamp>.md`
+- Data integrity reports: `.claudedocs/metrics/data-validation-<timestamp>.md`
+- Rollback procedures: `.claudedocs/summaries/rollback-plan-<timestamp>.md`
+- Ensure directory exists: `mkdir -p .claudedocs/reports/ .claudedocs/metrics/ .claudedocs/summaries/`
+- Include report location in output: "📄 Migration report saved to: [path]"
+
+Deliverables: Migration script with rollback capability, execution report with statistics, backup confirmation, data integrity verification, and rollback procedure documentation.

package/#Tools/SuperClaude/.claude/commands/scan.md

@@ -0,0 +1,163 @@
+@include shared/constants.yml#Process_Symbols
+
+@include shared/command-templates.yml#Universal_Flags
+
+Scan code, ops, or systems→security vulns & safety issues in $ARGUMENTS.
+
+Scan type w/ flags:
+
+--validate flag:
+- Pre-execution safety validation | Op risk assessment
+- Permission & access checks | Quick safety verification before running commands
+
+--security flag:
+- Comprehensive security analysis
+- w/ --owasp: Focus→OWASP Top 10 | w/ --deps: Deps vuln scan
+- Deep security audit→code & cfg
+
+## Validation Mode (--validate)
+
+Pre-execution safety checks:
+
+**Security validation**:
+- Path traversal prevention | No execution outside project boundaries
+- Secrets and credentials detection
+- Permission verification
+- Input sanitization checks
+
+**Code validation**:
+- Syntax correctness
+- Import and dependency verification
+- Breaking change detection
+- Configuration validity
+- Type safety checks
+
+**Operation validation**:
+- Git state verification
+- Branch protection compliance
+- Resource availability
+- Rollback capability
+- Blast radius assessment
+
+**Risk assessment**:
+- Calculate risk score (1-10)
+- Impact analysis (data loss, downtime)
+- Reversibility evaluation
+- Required permissions check
+- Compliance verification
+
+Validation workflow:
+1. Parse intended operation
+2. Run all applicable checks
+3. Generate risk score
+4. Report with clear indicators:
+   - ✅ Pass - Safe to proceed
+   - ⚠️ Warning - Caution advised
+   - ❌ Block - Do not proceed
+
+Integration behavior:
+- Auto-trigger for risky operations
+- Chain with execution: scan --validate && execute
+- Block CRITICAL [10] severity issues
+- Require confirmation for HIGH [7-9] risks
+
+## Security Mode (--security)
+
+Comprehensive security analysis:
+
+**OWASP Top 10 checks**:
+- Injection flaws (SQL, NoSQL, OS command, LDAP)
+- Broken authentication and session management
+- Sensitive data exposure
+- XML external entities (XXE)
+- Broken access control
+- Security misconfiguration
+- Cross-site scripting (XSS)
+- Insecure deserialization
+- Using components with known vulnerabilities
+- Insufficient logging and monitoring
+
+**Code security analysis**:
+- Input validation gaps
+- Output encoding issues
+- Authentication weaknesses
+- Authorization flaws
+- Cryptographic problems
+- Error handling leaks
+- Session management
+- File operation safety
+
+**Dependency scanning**:
+- Known CVE detection
+- Outdated package identification
+- License compliance check
+- Transitive dependency analysis
+- Security patch availability
+- Typosquatting detection
+
+**Configuration security**:
+- Hardcoded secrets scan
+- Environment variable safety
+- Permission configurations
+- Network exposure
+- TLS/SSL settings
+- CORS policies
+- Security headers
+
+**Infrastructure security**:
+- Open ports and services
+- Firewall rules
+- Access control lists
+- Encryption in transit/rest
+- Backup security
+- Logging configuration
+
+## Quick Scan Options
+
+With --quick flag:
+- Fast validation for common issues
+- Skip deep analysis
+- Focus on critical problems
+- Rapid feedback loop
+
+With --strict flag:
+- Zero-tolerance mode
+- Flag all potential issues
+- Enforce best practices
+- Require explicit overrides
+
+## Scan Output
+
+Results include:
+- Executive summary with risk level
+- Detailed findings by category
+- Severity ratings (CRITICAL/HIGH/MEDIUM/LOW)
+- Specific remediation steps
+- Code examples for fixes
+- References to security resources
+- Compliance mapping (if applicable)
+
+Severity classification:
+- **CRITICAL [10]**: Immediate action required
+- **HIGH [7-9]**: Fix before deployment
+- **MEDIUM [4-6]**: Address in next sprint
+- **LOW [1-3]**: Best practice improvements
+
+## Integration
+
+Works with other commands:
+- Run before deploy: `/project:scan --validate && /project:deploy`
+- Security gate: `/project:scan --security --strict`
+- CI/CD integration: Fail build on HIGH+ findings
+- Pre-commit hooks: Quick validation
+
+Best practices:
+- Run validation before any risky operation
+- Schedule regular security scans
+- Track and trend findings over time
+- Automate where possible
+- Document exceptions with justification
+
+@include shared/command-templates.yml#Report_Output
+
+@include shared/constants.yml#Success_Messages

package/#Tools/SuperClaude/.claude/commands/shared/ambiguity-check.yml

@@ -0,0 +1,40 @@
+# Ambiguity Check Patterns
+
+## Integration
+
+```yaml
+Commands:
+  Include: shared/ambiguity-check.yml
+  Check: ambiguity_level() before execute
+  Block: CRITICAL ambiguity
+
+Detection:
+  Keywords: See RULES.md § Ambiguity
+  Missing: Path|Scope|Criteria
+  Risk: Combine w/ operation risk
+
+Response:
+  LOW: Proceed w/ assumption note
+  MEDIUM: Suggest interpretation+confirm  
+  HIGH: Present options A/B/C
+  CRITICAL: Block until clarified
+```
+
+## Quick Checks
+
+```yaml
+Path Ambiguity:
+  "update config" → Which file?
+  "fix tests" → Which tests?
+  "deploy" → Which environment?
+
+Scope Ambiguity:
+  "refactor" → Single file or module?
+  "optimize" → Speed or memory?
+  "add security" → What threats?
+
+Action Ambiguity:
+  "make it work" → Define "work"
+  "fix the bug" → Which bug?
+  "improve" → What aspect?
+```

package/#Tools/SuperClaude/.claude/commands/shared/audit.yml

@@ -0,0 +1,21 @@
+# Audit Logging
+
+```yaml
+Format: <timestamp>|<operation>|<risk>|<user>|<status>|<details>
+Location: .claudedocs/audit/YYYY-MM-DD.log | Daily rotate | 10MB max | 30d retention
+
+Risk: CRIT[10] | HIGH[7-9] | MED[4-6] | LOW[1-3]
+
+Required:
+  - File deletions/overwrites
+  - Git operations (push,force,rebase)
+  - Database operations
+  - Deployments
+  - Security modifications
+  - Checkpoints/rollbacks
+
+Integration:
+  Start: audit_log("start",op,risk)
+  Success: audit_log("success",op,risk)
+  Failure: audit_log("fail",op,risk,error)
+```