appiq-solution 1.4.7 → 1.4.9

package/SuperClaude/.claude/commands/shared/git-operations.yml

@@ -1,217 +0,0 @@
-# Git Ops Config
-
-## Command Workflows
-```yaml
-Status_Workflow:
-  1. Check working tree: git status --porcelain
-  2. Current branch: git branch --show-current
-  3. Upstream tracking: git rev-parse --abbrev-ref @{u}
-  4. Stash list: git stash list
-  5. Recent commits: git log --oneline -5
-  6. Unpushed commits: git log @{u}..HEAD --oneline
-  7. Remote status: git remote -v && git fetch --dry-run
-
-Commit_Workflow:
-  Pre_checks:
-    - Working tree status
-    - Branch protection rules
-    - Pre-commit hooks available
-  Staging:
-    - Interactive: git add -p
-    - All tracked: git add -u
-    - Specific: git add <paths>
-  Message:
-    - Check conventions: conventional commits, gitmoji
-    - Generate from changes if not provided
-    - Include issue refs
-  Post_commit:
-    - Run tests if cfg'd
-    - Update checkpoint manifest
-    - Show commit confirmation
-
-Branch_Workflow:
-  Create:
-    - From current: git checkout -b <name>
-    - From base: git checkout -b <name> <base>
-    - Set upstream: git push -u origin <name>
-  Switch:
-    - Check uncommitted changes
-    - Stash if needed
-    - git checkout <branch>
-  Delete:
-    - Check if merged: git branch --merged
-    - Local: git branch -d <name>
-    - Remote: git push origin --delete <name>
-  Protection:
-    - Never delete: main, master, develop
-    - Warn on: release/*, hotfix/*
-
-Sync_Workflow:
-  Fetch:
-    - All remotes: git fetch --all --prune
-    - Tags: git fetch --tags
-  Pull:
-    - With rebase: git pull --rebase
-    - Preserve merges: git pull --rebase=preserve
-    - Autostash: git pull --autostash
-  Push:
-    - Current branch: git push
-    - With lease: git push --force-with-lease
-    - Tags: git push --tags
-  Submodules:
-    - Update: git submodule update --init --recursive
-    - Sync: git submodule sync --recursive
-
-Merge_Workflow:
-  Pre_merge:
-    - Create checkpoint
-    - Fetch target branch
-    - Check for conflicts: git merge --no-commit --no-ff
-  Merge_strategies:
-    - Fast-forward: git merge --ff-only
-    - No fast-forward: git merge --no-ff
-    - Squash: git merge --squash
-  Conflict_resolution:
-    - List conflicts: git diff --name-only --diff-filter=U
-    - Use theirs: git checkout --theirs <file>
-    - Use ours: git checkout --ours <file>
-    - Manual resolution with markers
-  Post_merge:
-    - Verify: git log --graph --oneline
-    - Run tests
-    - Update documentation
-```
-
-## Safety Mechanisms
-```yaml
-Checkpoints:
-  Auto_create:
-    - Before merge
-    - Before rebase
-    - Before reset --hard
-    - Before force push
-  Format: checkpoint/git-<operation>-<timestamp>
-  
-Confirmations:
-  Required_for:
-    - Force push to remote
-    - Delete unmerged branch
-    - Reset --hard
-    - Rebase published commits
-    - Checkout with uncommitted changes
-  
-Validations:
-  Pre_commit:
-    - No secrets or API keys
-    - No large files (>100MB)
-    - No merge conflict markers
-    - Code passes linting
-  Pre_push:
-    - Tests pass
-    - No WIP commits
-    - Branch naming conventions
-    - Protected branch rules
-```
-
-## Conflict Resolution Patterns
-```yaml
-Common_Conflicts:
-  Package_files:
-    - package-lock.json: Regenerate after merge
-    - yarn.lock: Run yarn install
-    - Gemfile.lock: Run bundle install
-  
-  Generated_files:
-    - Build artifacts: Regenerate
-    - Compiled assets: Recompile
-    - Documentation: Regenerate
-  
-  Code_conflicts:
-    - Imports: Combine both sets
-    - Function signatures: Communicate with team
-    - Feature flags: Usually keep both
-
-Resolution_Strategy:
-  1. Understand both changes
-  2. Communicate with authors
-  3. Test both functionalities
-  4. Document resolution
-  5. Consider refactoring
-```
-
-## Branch Patterns
-```yaml
-Naming_Conventions:
-  Feature: feature/<ticket>-<description>
-  Bugfix: bugfix/<ticket>-<description>
-  Hotfix: hotfix/<ticket>-<description>
-  Release: release/<version>
-  Experimental: exp/<description>
-
-Protection_Rules:
-  main/master:
-    - No direct commits
-    - Require PR reviews
-    - Must pass CI/CD
-    - No force push
-  develop:
-    - Require PR for features
-    - Allow hotfix direct merge
-    - Must pass tests
-  release/*:
-    - Only fixes allowed
-    - Version bumps only
-    - Tag on completion
-```
-
-## Commit Patterns
-```yaml
-Message_Format:
-  Conventional: <type>(<scope>): <subject>
-  Gitmoji: <emoji> <type>: <subject>
-  Simple: <Type>: <Subject>
-
-Types:
-  feat: New feature
-  fix: Bug fix
-  docs: Documentation
-  style: Code style (no logic change)
-  refactor: Code restructuring
-  test: Test additions/changes
-  chore: Build process/tools
-  perf: Performance improvements
-  ci: CI/CD changes
-
-Best_Practices:
-  - Atomic commits (one change per commit)
-  - Present tense, imperative mood
-  - Reference issues/tickets
-  - Explain why, not what
-  - Keep subject line < 50 chars
-  - Wrap body at 72 chars
-```
-
-## Automation Hooks
-```yaml
-Pre_commit:
-  - Lint staged files
-  - Run type checking
-  - Format code
-  - Check for secrets
-  - Validate commit message
-
-Pre_push:
-  - Run full test suite
-  - Check code coverage
-  - Validate branch name
-  - Check for WIP commits
-
-Post_merge:
-  - Install new dependencies
-  - Run database migrations
-  - Update documentation
-  - Notify team members
-```
-
----
-*Git Operations: Comprehensive git workflow management*

package/SuperClaude/.claude/commands/shared/git-workflow.yml

@@ -1,37 +0,0 @@
-# Git Workflow Integration
-
-## Auto-Check
-```yaml
-Before Major Changes:
-  - git status | Check for uncommitted changes
-  - git branch | Verify correct branch
-  - git fetch | Check for remote updates
-  
-Suggest Commits:
-  - After feature completion
-  - Before switching branches
-  - At logical breakpoints
-  
-Conflict Detection:
-  - Scan for merge conflict markers
-  - Offer resolution patterns
-  - Guide through conflict resolution
-```
-
-## Workflow Patterns
-```yaml
-Feature Work:
-  New feature→Suggest feature branch
-  Multiple changes→Suggest incremental commits
-  Experimental→Suggest separate branch
-  
-Clean State:
-  Uncommitted changes→"Commit first?" or "Stash?"
-  Wrong branch→"Switch→feature branch?"
-  Conflicts → "Resolve conflicts first"
-  
-Branch Awareness:
-  main/master → Warn about direct changes
-  feature/* → Encourage commits
-  hotfix/* → Emphasize testing
-```

package/SuperClaude/.claude/commands/shared/implementation.yml

@@ -1,199 +0,0 @@
-# Impl Hooks
-
-## How Claude Code Uses These Patterns
-
-```yaml
-Pattern Loading:
-  On Start: Load CLAUDE.md→RULES.md (core behavioral rules)
-  On /persona:: Check if PERSONAS.md loaded→Load if needed→Cache session
-  On MCP ref: Check if MCP.md loaded→Load if needed→Cache session
-  Commands: Parse .claude/commands/*.md on /user: trigger→Cache recent 5
-  Shared: Include shared/*.yml when referenced by active commands
-
-Severity Enforcement:
-  CRITICAL[10]: Block op & explain why
-  HIGH[7-9]: Warn user & require confirmation
-  MEDIUM[4-6]: Suggest improvement & continue
-  LOW[1-3]: Note in output & proceed
-
-Auto-Triggers:
-  File Open: Check extension→Load PERSONAS.md if needed→Activate persona
-  Command Start: Load command def→Check ambiguity→Clarify if needed
-  MCP Usage: Load MCP.md if needed→Select appropriate tool
-  Risky Op: Create checkpoint→Log audit→Validate
-  Error: Activate analyzer→Debug workflow
-```
-
-## Pattern Integration
-
-```yaml
-Todo Management:
-  3+ steps → TodoWrite() with tasks
-  Status → Update immediately on change
-  Complete → Mark done & suggest next
-
-MCP Selection:
-  Parse request → Check complexity → Select tool
-  Simple → Use native | Complex → Use MCP
-  Monitor tokens → Switch/abort if exceeded
-
-Context Management:
-  Track % → Warn at 60% → Force compact at 90%
-  Task complete → Auto-compact context
-  Project switch → Clear context
-```
-
-## Command Execution
-
-```yaml
-Pre-Execution:
-  1. Parse command & args
-  2. Check thinking mode flags:
-     - --think: Activate standard thinking mode (4K tokens)
-     - --think-hard: Activate deep analysis mode (10K tokens)  
-     - --ultrathink: Activate critical analysis mode (32K tokens)
-     - Default: Basic mode if no thinking flag present
-  3. Check MCP control flags:
-     - --c7/--no-c7: Control Context7 documentation server
-     - --seq/--no-seq: Control Sequential thinking server
-     - --magic/--no-magic: Control Magic UI builder
-     - --pup/--no-pup: Control Puppeteer browser automation
-     - --all-mcp: Enable all MCP servers
-     - --no-mcp: Disable all MCP servers
-  4. Check risk level (shared/planning-mode.yml)
-  5. If --plan flag → Show plan → await approval
-  6. Check ambiguity (shared/ambiguity-check.yml)
-  7. Research verification (shared/research-first.yml):
-     - External library detected → C7 resolve + get-docs REQUIRED
-     - New UI component needed → Magic search or WebSearch patterns
-     - API integration found → Official docs lookup REQUIRED
-     - Unknown pattern detected → Sequential analysis + research
-     - Block if: No research performed for external dependencies
-     - Cache: Store researched patterns for session reuse
-  8. Preemptive validation:
-     - Dependencies: package.json vs node_modules | Required tools installed
-     - Permissions: File write access | Command availability
-     - State: Clean git status for risky ops | No conflicting processes
-     - Environment: Correct versions | Required env vars set
-  9. Validate permissions (shared/validation.yml)
-  10. Create checkpoint if risky
-  11. Log start (shared/audit.yml)
-  12. Documentation directory check (shared/documentation-dirs.yml):
-      - Report generation? → Ensure .claudedocs/[subdirs] exist
-      - Project docs? → Ensure /docs/[category] exists  
-      - Create directories if missing with proper permissions (755)
-      - Validate write permissions to target directories
-  13. UltraCompressed check (shared/ultracompressed.yml):
-      - --uc flag? → Apply compression rules to all output
-      - Context >70%? → Suggest --uc mode
-      - Token budget? → Auto-enable compression
-      - Generate legend at start of compressed docs
-
-During:
-  - Update todo status
-  - Show progress indicators
-  - Handle errors gracefully
-  - Keep user informed
-
-Post-Execution:
-  - Log completion/failure
-  - Update todos
-  - If report generated → Note location in output: "📄 Report saved to: [path]"
-  - If docs created → Update /docs/index.md with new entries
-  - Suggest next steps
-  - Compact context if needed
-```
-
-## Persona Activation
-
-```yaml
-File-Based:
-  *.tsx opened → frontend persona active
-  *.sql opened → data persona active
-  Dockerfile → devops persona active
-
-Keyword-Based:
-  "optimize" in request → performance persona
-  "secure" mentioned → security persona
-  "refactor" → refactorer persona
-
-Context-Based:
-  Error trace → analyzer persona
-  Architecture question → architect persona
-  Learning request → mentor persona
-
-Multi-Persona:
-  Complex task → Sequential activation
-  Parallel work → Concurrent personas
-  Handoff → Share context between
-```
-
-## Error Handling
-
-```yaml
-Pattern Detection:
-  Match error → Error type in patterns.yml
-  Syntax → Check syntax highlighting
-  Runtime → Validate inputs & types
-  Logic → Trace execution flow
-
-Recovery:
-  Try operation → Catch error → Check pattern
-  Known → Apply fix pattern
-  Unknown → Activate analyzer → Debug
-  Can't fix → Explain & suggest manual fix
-```
-
-## Token Optimization
-
-```yaml
-Real-Time:
-  Count tokens → Apply reduction patterns
-  Remove listed words → Use symbols
-  YAML format → Compress output
-  Reference > repeat → Link to existing
-
-Batch Operations:
-  Group similar → Single operation
-  Parallel when possible → Reduce time
-  Cache results → Avoid re-computation
-```
-
-## Unified Behaviors
-
-```yaml
-Error Format:
-  All commands: [COMMAND] Error: What→Why→Fix
-  Example: [BUILD] Error: Module X failed→Missing dep Y→Run npm install Y
-
-Result Format:
-  Success: ✓ Action (Xms) | Details
-  Warning: ⚠ Issue | Impact | Suggestion  
-  Failure: ✗ Error | Reason | Recovery
-
-Command Memory:
-  Store: After each command → .claude/session/[command].cache
-  Reuse: Check cache → Use if valid → Note "using prior analysis"
-  Clear: On file change → Invalidate related caches
-
-## Loading Optimization
-```yaml
-Component Loading:
-  Core: CLAUDE.md + RULES.md loaded on startup (~3500 tokens)
-  Personas: Load on /persona: trigger → Cache for session
-  MCP: Load on MCP tool reference → Cache for session
-  Commands: Load on /user: trigger → Cache recent 5
-  
-Token Savings:
-  Simple tasks: 43% reduction (6100→3500 tokens)
-  With personas: 33% reduction (6100→4100 tokens)
-  With commands: 20-30% reduction (varies by usage)
-  
-Cache Strategy:
-  Session-based: Keep loaded components until session ends
-  LRU: Evict least recently used when memory limits reached
-  Preload: Common patterns loaded proactively
-```
-
----
-*Implementation: How patterns become actions*

package/SuperClaude/.claude/commands/shared/loading-config.yml

@@ -1,73 +0,0 @@
-# Loading Config for Token Optimization & Perf
-
-## Core Config (Always Load)
-```yaml
-Core:
-  Always: [CLAUDE.md, RULES.md, PERSONAS.md, MCP.md]
-  Priority: Critical behavioral rules, personas & MCP patterns
-  Size: ~4600 tokens
-  Reason: Essential for all Claude Code behavior, personas globally available
-  
-Global Availability:
-  PERSONAS.md: All 9 cognitive archetypes available via /persona:
-  MCP.md: All MCP patterns available automatically
-  
-Commands:
-  Trigger: /user:
-  Path: .claude/commands/
-  Size: ~50 tokens per command
-  Cache: Most recent 5 commands
-  Index: command names & risk levels only
-  
-SharedResources:
-  LoadWith: Associated commands
-  Path: .claude/commands/shared/
-  Size: ~150 tokens per YAML
-  Examples:
-    - cleanup-patterns.yml→loads w/ /user:cleanup
-    - git-workflow.yml→loads w/ git ops
-    - planning-mode.yml→loads w/ risky commands
-```
-
-## Advanced Loading Optimization
-```yaml
-Smart Loading Strategies:
-  Predictive: Anticipate likely-needed resources based on command patterns
-  Contextual: Load resources based on project type and user behavior
-  Lazy: Defer loading non-critical resources until explicitly needed
-  Incremental: Load minimal first, expand as complexity increases
-  
-Intelligent Caching:
-  Command Frequency: Cache most-used commands permanently
-  Workflow Patterns: Preload resources for common command sequences
-  User Preferences: Remember and preload user's preferred tools
-  Session Context: Keep relevant context across related operations
-  
-Token Efficiency:
-  Base load: 4600 tokens (CLAUDE.md + RULES.md + PERSONAS.md + MCP.md)
-  Optimized commands: 4650-4700 tokens (~50 tokens per command)
-  Smart shared resources: Load only when needed, avg 150-300 tokens
-  Performance gain: ~20-30% reduction through intelligent loading
-  Trade-off: Higher base load for consistent global functionality
-  
-Context Compression:
-  Auto UltraCompressed: Enable when context approaches limits
-  Selective Detail: Keep summaries, load detail on demand
-  Result Caching: Store and reuse expensive analysis results
-  Pattern Recognition: Learn and optimize based on usage patterns
-```
-
-## Performance Monitoring Integration
-```yaml
-Loading Metrics:
-  Time to Load: Track component loading speed
-  Cache Hit Rate: Measure effectiveness of caching strategies
-  Memory Usage: Monitor total context size and optimization opportunities
-  User Satisfaction: Track command completion success rates
-  
-Adaptive Optimization:
-  Slow Loading: Automatically switch to lighter alternatives
-  High Memory: Trigger context compression and cleanup
-  Cache Misses: Adjust caching strategy based on usage patterns
-  Performance Degradation: Fall back to minimal loading mode
-```

package/SuperClaude/.claude/commands/shared/mcp-flags.yml

@@ -1,109 +0,0 @@
-# MCP Server Flag Config
-
-## MCP Control Flags
-```yaml
-Command_Flags:
-  # Context7 Docs Server
-  --c7: "Enable Context7→lib docs lookup"
-  --no-c7: "Disable Context7 (native tools only)"
-  
-  # Sequential Thinking Server  
-  --seq: "Enable Sequential thinking→complex analysis"
-  --no-seq: "Disable Sequential thinking"
-  
-  # Magic UI Builder Server
-  --magic: "Enable Magic UI component generation"
-  --no-magic: "Disable Magic UI builder"
-  
-  # Puppeteer Browser Control Server
-  --pup: "Enable Puppeteer→browser testing"
-  --no-pup: "Disable Puppeteer"
-  
-  # Combined Controls
-  --all-mcp: "Enable all MCP servers"
-  --no-mcp: "Disable all MCP servers (native tools only)"
-  
-Usage_Examples:
-  - /user:analyze --code --c7          # Use Context7 for library docs
-  - /user:design --api --seq           # Use Sequential for architecture
-  - /user:build --react --magic        # Use Magic for UI components
-  - /user:test --e2e --pup            # Use Puppeteer for browser tests
-  - /user:troubleshoot --no-mcp       # Native tools only for debugging
-```
-
-## MCP Server Capabilities
-```yaml
-Context7 (--c7):
-  Purpose: Library documentation and code examples
-  Best_for: API usage, framework patterns, library integration
-  Token_cost: Low-Medium (100-2000 tokens)
-  
-Sequential (--seq):
-  Purpose: Step-by-step complex problem solving
-  Best_for: Architecture, debugging, system design
-  Token_cost: Medium-High (500-10000 tokens)
-  
-Magic (--magic):
-  Purpose: UI component generation with 21st.dev
-  Best_for: React/Vue components, UI patterns
-  Token_cost: Medium (500-2000 tokens)
-  
-Puppeteer (--pup):
-  Purpose: Browser automation and testing
-  Best_for: E2E tests, screenshots, web scraping
-  Token_cost: Low (minimal tokens)
-```
-
-## Smart Defaults & Recommendations
-```yaml
-Command_Defaults:
-  # Commands that benefit from specific MCP servers
-  analyze + --architecture: Suggest --seq for system analysis
-  build + --react: Suggest --magic for UI components
-  test + --e2e: Suggest --pup for browser testing
-  explain + library_name: Suggest --c7 for documentation
-  design + --api: Suggest --seq --c7 for comprehensive design
-  troubleshoot + --investigate: Suggest --seq for root cause analysis
-  improve + --performance: Suggest --seq --pup for optimization analysis
-  
-Intelligent Combinations:
-  --magic + --pup: Generate UI components and test them immediately
-  --seq + --c7: Complex analysis with authoritative documentation
-  --seq + --think-hard: Deep architectural analysis with documentation
-  --c7 + --uc: Research with compressed output for token efficiency
-  
-Conflict_Resolution:
-  --no-mcp overrides: All individual MCP flags
-  Explicit beats implicit: --no-c7 overrides auto-activation
-  Cost awareness: Warn if multiple high-cost MCPs selected
-  Token budget: Auto-suggest --uc when approaching limits
-```
-
-## Integration with Other Flags
-```yaml
-Synergies:
-  --think + --seq: Enhanced analysis with Sequential thinking
-  --ultrathink + --all-mcp: Maximum capability for critical tasks
-  --plan + --seq: Better planning with Sequential analysis
-  --magic + --pup: Generate and test UI components
-  
-Anti-patterns:
-  --no-mcp + --c7: Conflicting flags (no-mcp wins)
-  Multiple costly: --seq --ultrathink (warn about token usage)
-```
-
-## Auto-Activation Override
-```yaml
-Flag_Priority:
-  1. Explicit flags (--c7, --no-c7) → Highest priority
-  2. Command defaults → Medium priority  
-  3. Context triggers → Lowest priority
-  
-Examples:
-  "React hooks" + --no-c7 → Skip Context7 despite keyword
-  /user:build --react --no-magic → Skip Magic UI despite React
-  /user:analyze --no-mcp → Pure native tools analysis
-```
-
----
-*MCP Flags: Explicit control over Model Context Protocol servers*