appiq-solution 1.2.0 → 1.3.1

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

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

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

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

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

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