appiq-solution 1.4.8 → 1.5.0

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

@@ -1,162 +0,0 @@
-@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

@@ -1,159 +0,0 @@
-# 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

@@ -1,65 +0,0 @@
-@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

@@ -1,76 +0,0 @@
-@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

@@ -1,163 +0,0 @@
-@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

@@ -1,40 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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)
-```