appiq-solution 1.4.7 → 1.4.9

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

@@ -1,97 +0,0 @@
-# UltraCompressed Docs Mode
-# ~70% token reduction via telegram-style+symbols+abbrevs
-
-Activation:
-  Flags: --ultracompressed | --uc
-  Natural: "ultracompressed" | "minimal tokens" | "telegram style"
-  Auto: Context>70% | Token budget specified | User preference
-
-Core_Rules:
-  Remove_Words:
-    Articles: the|a|an
-    Conjunctions: and|or|but|however|therefore
-    Prepositions: of|in|on|at|to|for|with|from|by
-    Fillers: that|which|who|very|really|quite|just
-    Verbose: "in order to"→to | "make sure"→ensure | "as well as"→&
-  
-  Symbol_Map:
-    →: to/leads to/results in
-    &: and/with/plus
-    @: at/located at
-    w/: with/including
-    w/o: without/excluding
-    +: add/plus/include
-    -: remove/minus/exclude
-    ∴: therefore/thus
-    ∵: because/since
-    ≈: approximately/about
-    ∀: for all/every
-    ∃: exists/there is
-    ⊂: subset of/part of
-    ≡: equivalent to/same as
-
-  Abbreviations:
-    cfg: configuration      fn: function
-    impl: implementation    req: require/request
-    resp: response         auth: authentication
-    db: database           api: API/interface
-    env: environment       dev: development
-    prod: production       deps: dependencies
-    arg: argument          param: parameter
-    val: value            obj: object
-    arr: array            str: string
-    num: number           bool: boolean
-    err: error            msg: message
-    usr: user             sys: system
-    lib: library          pkg: package
-    ctx: context          ref: reference
-    docs: documentation    spec: specification
-
-Structure_Rules:
-  Headings: <20 chars | No articles | Symbols OK
-  Sentences: <50 chars | Telegram style | No punctuation if clear
-  Paragraphs: <100 chars | 3 sentences max | Lists preferred
-  Lists: Bullets>numbers | No full sentences | Key info only
-  Tables: Headers abbreviated | Cell content minimal | Symbols OK
-
-Format_Hierarchy:
-  1. YAML/JSON (structured data)
-  2. Tables (comparison/reference)
-  3. Bullet lists (enumeration)
-  4. Numbered lists (sequences)
-  5. Prose (avoid when possible)
-
-Content_Rules:
-  NO: Introductions|Conclusions|Transitions|Explanations of obvious
-  NO: "Getting Started"|"Overview"|"Introduction" sections
-  NO: Filler phrases|Politeness|Redundancy
-  YES: Direct information|Code>text|Examples>description
-  YES: Symbols>words|Abbreviations>full terms|Active>passive
-
-Legend_Generation:
-  When: Start of each doc | When new symbols/abbrevs used
-  Format: Compact table | Only used items | Sort by frequency
-  Location: After title | Before content | Collapsible if supported
-  Example: |
-    ## Legend
-    | Symbol | Meaning | | Abbrev | Meaning |
-    |--------|---------|---|--------|---------|
-    | → | leads to | | cfg | configuration |
-    | & | and/with | | fn | function |
-    | w/ | with | | impl | implementation |
-
-Example_Transformations:
-  Before: "This section provides an introduction to getting started with the authentication system"
-  After: "Auth Setup"
-  
-  Before: "In order to configure the database connection, you need to set the following environment variables"
-  After: "DB cfg: Set env vars:"
-  
-  Before: "The function takes three parameters and returns a boolean value"
-  After: "fn(3 params)→bool"
-
-Quality_Checks:
-  Token_Reduction: Target 70% | Measure before/after
-  Clarity_Score: Must remain >80% | Test w/ context
-  Info_Density: Maximize bits/token | No info loss
-  Legend_Required: Always include for symbols & abbreviations

package/#Tools/SuperClaude/.claude/commands/shared/user-experience.yml

@@ -1,208 +0,0 @@
-# UX & Interface Patterns
-
-## User Interaction Principles
-
-```yaml
-Clarity & Communication:
-  Clear Intent: Every command should have obvious purpose
-  Immediate Feedback: Show what's happening in real-time
-  Progress Indicators: Display completion % & ETA
-  Result Summary: Concise overview→what was accomplished
-  
-Predictability:
-  Consistent Behavior: Same flags work same way across commands
-  Expected Outputs: Users should know what→expect
-  Stable Interface: Minimize breaking changes
-  Docs: Always up-to-date & comprehensive
-  
-Efficiency:
-  Smart Defaults: Most common options should be default
-  Minimal Typing: Short, memorable command names & flags
-  Context Awareness: Remember previous ops & preferences
-  Workflow Optimization: Common sequences should be streamlined
-```
-
-## Progressive Disclosure
-
-```yaml
-Beginner Mode:
-  Guided Experience: Step-by-step instructions
-  Explanatory Output: Why each step is needed
-  Safety Rails: Prevent destructive operations
-  Learning Resources: Links to documentation and tutorials
-  
-Intermediate Mode:
-  Balanced Output: Key information without overwhelming detail
-  Useful Shortcuts: Common flag combinations and aliases
-  Context Hints: Suggestions based on current state
-  Flexible Options: More configuration choices available
-  
-Expert Mode:
-  Minimal Output: Just essential information
-  Advanced Features: Full power and customization
-  Direct Control: Override safety checks when needed
-  Performance Focus: Optimized for speed and efficiency
-
-Adaptive Interface:
-  Usage Detection: Automatically adjust based on user behavior
-  Preference Learning: Remember user's preferred interaction style
-  Context Switching: Different modes for different project types
-  Customization: Allow users to configure their experience
-```
-
-## Workflow Discovery & Guidance
-
-```yaml
-Command Suggestions:
-  Context-Aware: Suggest next logical steps based on current state
-  Common Patterns: Recommend proven workflow sequences
-  Problem-Specific: Tailored suggestions for specific issues
-  Learning Opportunities: Introduce new features when relevant
-  
-Interactive Help:
-  Command Help: Detailed usage for specific commands
-  Flag Explanations: What each flag does and when to use it
-  Example Library: Real-world usage examples
-  Troubleshooting: Common issues and solutions
-  
-Workflow Templates:
-  Project Types: Predefined workflows for different project types
-  Use Cases: Common scenarios with step-by-step guides
-  Best Practices: Recommended approaches for quality and safety
-  Customization: Allow users to create and share their own templates
-```
-
-## Error Prevention & Recovery
-
-```yaml
-Proactive Prevention:
-  Validation: Check prerequisites before execution
-  Warnings: Alert about potential issues or risks
-  Confirmation: Require explicit approval for destructive operations
-  Simulation: Dry-run mode to preview changes
-  
-Graceful Degradation:
-  Partial Success: Continue with what's possible when some parts fail
-  Alternative Paths: Suggest different approaches when primary fails
-  Fallback Options: Automatic switches to backup methods
-  Recovery Guidance: Clear steps to resolve issues and continue
-  
-Learning from Errors:
-  Pattern Recognition: Identify common user mistakes
-  Preventive Measures: Add checks for frequently encountered issues
-  Documentation Updates: Improve help based on common confusion
-  Interface Improvements: Redesign confusing or error-prone interactions
-```
-
-## Performance & Responsiveness
-
-```yaml
-Response Time Expectations:
-  Immediate (<100ms): Command acknowledgment, simple queries
-  Fast (<1s): File operations, simple analysis
-  Moderate (<10s): Complex analysis, building, testing
-  Long (>10s): Deployment, migration, comprehensive operations
-  
-Progress Communication:
-  Quick Start: Show immediate activity indicator
-  Detailed Progress: Break down long operations into steps
-  Time Estimates: Provide realistic completion predictions
-  Cancellation: Allow users to interrupt long operations
-  
-Resource Management:
-  Token Awareness: Monitor and display context usage
-  Memory Efficiency: Optimize for large codebases
-  Network Usage: Minimize unnecessary requests
-  Caching: Reuse results when appropriate
-```
-
-## Accessibility & Inclusivity
-
-```yaml
-Output Formatting:
-  Screen Readers: Structured output that reads well
-  Color Blind: Don't rely solely on color for information
-  Low Vision: High contrast, clear typography
-  Motor Impairments: Keyboard shortcuts, minimal mouse requirements
-  
-Language & Terminology:
-  Clear Language: Avoid jargon when possible
-  Consistent Terms: Use same words for same concepts
-  Internationalization: Support for multiple languages
-  Cultural Sensitivity: Inclusive examples and references
-  
-Learning Styles:
-  Visual Learners: Diagrams, charts, visual representations
-  Auditory Learners: Clear explanations, logical flow
-  Kinesthetic Learners: Interactive exercises, hands-on examples
-  Reading/Writing: Comprehensive documentation, examples
-```
-
-## Customization & Personalization
-
-```yaml
-User Preferences:
-  Output Verbosity: Detailed, normal, minimal
-  Color Schemes: Support for different terminal themes
-  Confirmation Levels: When to ask for approval
-  Default Flags: Commonly used flags for each command
-  
-Project Configuration:
-  Workflow Presets: Saved command sequences for project
-  Quality Gates: Project-specific standards and thresholds
-  Tool Preferences: Choice of testing frameworks, linters, etc.
-  Environment Settings: Development, staging, production configs
-  
-Team Settings:
-  Shared Workflows: Common patterns across team members
-  Code Standards: Enforced quality and style requirements
-  Review Processes: Required steps before deployment
-  Communication: How and when to notify team members
-```
-
-## Feedback & Improvement
-
-```yaml
-Usage Analytics:
-  Command Frequency: Which commands are used most often
-  Error Patterns: Common failure points and user confusion
-  Workflow Analysis: How users combine commands
-  Performance Metrics: Response times and user satisfaction
-  
-User Feedback:
-  In-App Feedback: Quick way to report issues or suggestions
-  Feature Requests: Channel for users to propose improvements
-  Bug Reports: Structured way to report problems
-  Success Stories: Positive feedback and use cases
-  
-Continuous Improvement:
-  Regular Updates: Frequent improvements based on feedback
-  A/B Testing: Try different approaches with different users
-  Community Input: Involve users in design decisions
-  Documentation: Keep help and examples current and useful
-```
-
-## Integration Points
-
-```yaml
-Command Integration:
-  Consistent Patterns: Same UX principles across all commands
-  Shared Components: Common UI elements and behaviors
-  Context Preservation: Maintain user state across commands
-  Workflow Continuity: Smooth transitions between operations
-  
-External Tools:
-  IDE Integration: Work well within development environments
-  Terminal Enhancement: Support for modern terminal features
-  Documentation Tools: Generate and maintain help content
-  Monitoring Systems: Track user experience metrics
-  
-Platform Adaptation:
-  Operating Systems: Optimize for Windows, macOS, Linux
-  Shell Environments: Work well with bash, zsh, PowerShell
-  Cloud Platforms: Integration with cloud development environments
-  Container Systems: Effective operation within containers
-```
-
----
-*User experience: Human-centered design for developer productivity*

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

@@ -1,54 +0,0 @@
-# Validation Patterns
-
-## Pre-Execution Checks
-
-```yaml
-Always Validate:
-  - Risky ops (delete, overwrite, deploy)
-  - Prod changes
-  - Permission escalations
-  - External API calls
-
-Check Sequence:
-  1. Ambiguity: shared/ambiguity-check.yml
-  2. Security: Path validation, secrets scan
-  3. Deps: Required tools/libs exist
-  4. Permissions: User has required access
-  5. State: Clean working tree, no conflicts
-```
-
-## Risk Assessment
-
-```yaml
-Risk Score (1-10):
-  Factors:
-    Data loss potential: +3
-    Irreversibility: +2
-    Scope of impact: +2
-    Security impact: +3
-  
-  Mitigations:
-    Backup available: -2
-    Test coverage: -1
-    Sandbox mode: -2
-    
-Actions by Score:
-  1-3: Proceed with note
-  4-6: Warn and confirm
-  7-9: Require explicit approval
-  10: Block execution
-```
-
-## Integration
-
-```yaml
-Commands:
-  Include: shared/validation.yml
-  Call: validate_pre_execution()
-  
-Auto-Trigger:
-  - Git push/force operations
-  - File deletions
-  - Database migrations
-  - Production deployments
-```

package/#Tools/SuperClaude/.claude/commands/shared/workflow-chains.yml

@@ -1,138 +0,0 @@
-# Workflow Chain Patterns
-
-## Command Chaining & Orchestration
-
-```yaml
-Chain Types:
-  Sequential: A→B→C (linear progression)
-  Parallel: A&B&C (concurrent execution)
-  Conditional: A&&B||C (success/failure paths)
-  Loop: A→B→(condition)→A (iterative workflows)
-
-Context Propagation:
-  Analysis Results: analyze→build|design|improve (use findings)
-  Design Patterns: design→build|document (apply arch)
-  Test Results: test→improve|deploy (use coverage/results)
-  Error Context: troubleshoot→improve|fix (use root cause)
-```
-
-## Predefined Workflow Chains
-
-```yaml
-Dev Workflows:
-  New Feature:
-    Chain: load→analyze→design→build→test→scan→deploy
-    Flags: --think for analysis, --magic for UI, --pup for E2E
-    Context: Each step uses previous outputs
-    
-  Bug Fix:
-    Chain: troubleshoot --investigate → troubleshoot --fix → test → commit
-    Flags: --think-hard for complex bugs, --seq for root cause
-    Context: Investigation findings guide fix implementation
-    
-  Code Review:
-    Chain: analyze --code → improve --quality → scan --validate → test
-    Flags: --think for comprehensive review
-    Context: Analysis results guide improvements
-
-Quality Workflows:
-  Performance Optimization:
-    Chain: analyze --profile → improve --performance → test → measure
-    Flags: --iterate --threshold 90% for continuous improvement
-    Context: Profile results guide optimization targets
-    
-  Security Hardening:
-    Chain: scan --security → improve --quality → scan --validate → test
-    Flags: --owasp for comprehensive security scanning
-    Context: Security findings drive improvements
-    
-  Tech Debt Reduction:
-    Chain: analyze --architecture → improve --quality → design → refactor
-    Flags: --think-hard for architectural analysis
-    Context: Debt analysis guides refactoring strategy
-
-Deployment Workflows:
-  Safe Production Deploy:
-    Chain: test --coverage → scan --validate → deploy --env staging → deploy --env prod
-    Flags: --plan for production deployment
-    Context: All gates must pass before production
-    
-  Emergency Rollback:
-    Chain: deploy --rollback → troubleshoot --investigate → git --checkpoint
-    Flags: --ultrathink for critical analysis
-    Context: Preserve state for post-incident analysis
-    
-  Blue-Green Deployment:
-    Chain: build → test → deploy --env blue → validate → switch-traffic → monitor
-    Flags: --think-hard for deployment strategy
-    Context: Health checks determine traffic switching
-```
-
-## Chain Execution Rules
-
-```yaml
-Success Propagation:
-  Continue: If command succeeds, pass context to next
-  Enhanced: Successful results enhance subsequent commands
-  Cache: Store intermediate results for reuse
-  
-Failure Handling:
-  Stop: Critical failures halt the chain
-  Retry: Transient failures trigger retry with backoff
-  Fallback: Use alternative command or skip non-critical steps
-  Recovery: Automatic rollback for deployments
-  
-Context Management:
-  Session: Keep context for entire workflow chain
-  Handoff: Pass specific results between commands
-  Cleanup: Clear context after chain completion
-  Checkpoint: Save state at critical points
-
-Performance Optimization:
-  Parallel: Execute independent commands concurrently
-  Skip: Avoid redundant operations based on context
-  Cache: Reuse expensive analysis results
-  Smart: Use previous results to inform decisions
-```
-
-## Chain Monitoring & Reporting
-
-```yaml
-Progress Tracking:
-  Status: Show current step and overall progress
-  Time: Estimate remaining time based on historical data
-  Bottlenecks: Identify slow steps for optimization
-  
-Error Reporting:
-  Point of Failure: Exact command and context where chain failed
-  Recovery Options: Available retry, rollback, or manual intervention
-  Impact Assessment: What was completed vs. what failed
-  
-Metrics Collection:
-  Duration: Total and per-step execution time
-  Success Rate: Chain completion percentage by workflow type
-  Resource Usage: Token consumption and tool utilization
-  Quality Gates: Pass/fail rates for validation steps
-```
-
-## Usage Examples
-
-```yaml
-CLI Usage:
-  Single Chain: /user:chain "new-feature" --think
-  Custom Chain: /user:analyze → /user:build → /user:test
-  Conditional: /user:test && /user:deploy || /user:troubleshoot
-  
-Flag Inheritance:
-  Global: /user:chain "deploy" --plan --think-hard
-  Specific: /user:analyze --code → /user:build --magic
-  Override: Chain defaults can be overridden per command
-  
-Context Queries:
-  Status: /user:chain-status (show current chain progress)
-  Results: /user:chain-results (show accumulated context)
-  History: /user:chain-history (show previous chain executions)
-```
-
----
-*Workflow chains: Orchestrated command execution with intelligent context sharing*

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

@@ -1,106 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Universal_Flags
-
-Spawn specialized sub-agent→handle specific task in $ARGUMENTS.
-
-Thinking flags (optional):
-- --think→multi-agent coordination planning
-- --think-hard→complex agent workflow design
-- --ultrathink→enterprise-scale agent orchestration
-
-Examples:
-- `/user:spawn --task "optimize database queries" --think` - Spawn data agent w/ coordination analysis
-- `/user:spawn --task "implement auth system" --think-hard` - Complex security impl w/ planning
-- `/user:spawn --task "migrate to microservices" --ultrathink` - Enterprise arch w/ full orchestration
-
---task flag:
-- Define clear, focused assignment | Provide necessary context & constraints
-- Set specific success criteria | Establish integration points
-
-Agent specializations:
-
-Frontend Agent:
-- UI/UX impl | Component dev
-- State management
-- Performance optimization
-- Accessibility compliance
-
-Backend Agent:
-- API development
-- Database operations
-- Business logic implementation
-- Integration services
-- Performance tuning
-
-DevOps Agent:
-- CI/CD pipeline setup
-- Infrastructure automation
-- Deployment strategies
-- Monitoring configuration
-- Security hardening
-
-Data Agent:
-- Data analysis and transformation
-- Database optimization
-- ETL pipeline development
-- Data quality assurance
-- Reporting solutions
-
-Best practices for spawning agents:
-
-1. Define Clear Scope
-   - Specific deliverables
-   - Clear boundaries
-   - Time constraints
-   - Quality expectations
-
-2. Provide Context
-   - Relevant code sections
-   - Documentation links
-   - Previous decisions
-   - Technical constraints
-
-3. Set Success Criteria
-   - Measurable outcomes
-   - Quality standards
-   - Integration requirements
-   - Testing expectations
-
-4. Coordinate Work
-   - Avoid conflicts with main work
-   - Plan integration points
-   - Handle dependencies
-   - Manage communication
-
-Integration workflow:
-1. Spawn agent with clear task definition
-2. Agent works independently on task
-3. Agent provides progress updates
-4. Results reviewed and integrated
-5. Knowledge transferred to main context
-
-## Benefits & Integration
-
-Benefits:
-- Parallel task execution
-- Specialized expertise
-- Focused context
-- Reduced cognitive load
-- Faster completion
-
-Research requirements for agent spawning:
-- Task specialization → Research domain-specific best practices and patterns
-- Agent coordination → WebSearch for multi-agent workflow patterns
-- Integration strategies → C7 documentation for framework-specific integration methods
-- Quality assurance → Must verify agent output validation patterns
-- Never spawn without clear scope - always research coordination patterns
-- All agent instructions must cite sources: // Source: [coordination guide reference]
-
-Report Output:
-- Agent coordination logs: `.claudedocs/reports/agent-spawn-<timestamp>.md`
-- Task completion summaries: `.claudedocs/summaries/agent-results-<timestamp>.md`
-- Ensure directory exists: `mkdir -p .claudedocs/reports/ .claudedocs/summaries/`
-- Include report location in output: "📄 Agent report saved to: [path]"
-
-Deliverables: Completed task results from spawned agent, integration plan for merging work, knowledge transfer documentation, coordination summary, and quality validation report.