appiq-solution 1.2.0 → 1.3.1

package/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/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/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/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)
+```

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

@@ -0,0 +1,28 @@
+# Checkpoint System
+
+```yaml
+Create:
+  Tag: git tag checkpoint/<type>-$(date +%Y%m%d-%H%M%S)
+  Stash: git stash push -m "checkpoint-<operation>-<timestamp>"
+  Manifest: .claude/checkpoints/manifest.yml
+  Summary: .claudedocs/summaries/checkpoint-<type>-<timestamp>.md
+
+Triggers:
+  Auto: Destructive|Refactor|Migration|Permissions|Deploy
+  Manual: User request|Risky ops|Experiments
+
+Types: feature|fix|refactor|migrate|deploy|manual
+
+Rollback:
+  Full: git reset --hard <checkpoint>
+  Selective: git checkout <checkpoint> -- <files>
+  Incremental: git revert <commits>
+  Stash: git stash pop
+
+Process:
+  - Verify checkpoint exists
+  - Check working tree
+  - Confirm w/ user
+  - Create pre-rollback checkpoint
+  - Execute & verify
+```

package/SuperClaude/.claude/commands/shared/cleanup-patterns.yml

@@ -0,0 +1,107 @@
+# Cleanup Patterns & Safety Rules
+
+## Safe→Remove (Auto)
+```yaml
+Files: 
+  - node_modules (if package-lock exists)
+  - dist/, build/, .next/, .nuxt/
+  - .tmp, temp/, cache/
+  - *.log, *.tmp, *.cache
+  - .DS_Store, thumbs.db, desktop.ini
+  - coverage/, .nyc_output/
+
+Code:
+  - console.log(), console.debug()
+  - debugger; statements
+  - TODO comments >30 days old
+  - Commented code blocks >7 days old
+  - Unused imports (if safe analysis confirms)
+```
+
+## Requires Confirmation (Manual)
+```yaml
+Files:
+  - Large files >10MB
+  - Untracked files in git
+  - User-specific cfgs (.vscode/, .idea/)
+  - DB files, logs w/ data
+
+Code:
+  - Unused functions (if no external refs)
+  - Dead code branches
+  - Deprecated API calls
+  - Large commented blocks
+
+Deps:
+  - Unused packages in package.json
+  - Packages w/ security vulns
+  - Major version updates
+  - Dev deps in prod
+```
+
+## Never Remove (Protected)
+```yaml
+Files:
+  - .env.example, .env.template
+  - README.md, LICENSE, CHANGELOG
+  - .gitignore, .gitattributes
+  - package.json, package-lock.json
+  - Source code in src/, lib/
+
+Code:
+  - Error handling blocks
+  - Type definitions
+  - API interfaces
+  - Configuration objects
+  - Test files
+
+Dependencies:
+  - Core framework packages
+  - Peer dependencies
+  - Packages used in production
+```
+
+## Risk Assessment
+```yaml
+LOW [1-3]:
+  - Temporary files
+  - Build artifacts  
+  - Log files
+  - Cache directories
+
+MEDIUM [4-6]:
+  - Unused code
+  - Old git branches
+  - Dev dependencies
+  - Config cleanup
+
+HIGH [7-9]:
+  - Dependency updates
+  - Git history changes
+  - Production configs
+  - Database cleanup
+
+CRITICAL [10]:
+  - Production data
+  - Security configs
+  - Core framework files
+  - User data
+```
+
+## Cleanup Strategies
+```yaml
+Incremental:
+  - Start with safe files
+  - Progress to code cleanup
+  - Finish with dependencies
+  
+Verification:
+  - Run tests after code cleanup
+  - Verify builds after file cleanup
+  - Check functionality after deps
+
+Rollback:
+  - Git commit before cleanup
+  - Backup configs before changes
+  - Document what was removed
+```

package/SuperClaude/.claude/commands/shared/command-memory.yml

@@ -0,0 +1,52 @@
+# Command Result Sharing & Context Mgmt
+
+## Enhanced Result Storage
+```yaml
+Cache Duration: Current session+persistent patterns
+Storage Format:
+  analyze: {issues[], metrics{}, hotspots[], patterns[]}
+  build: {artifacts[], errors[], warnings[], perf{}}
+  test: {passed[], failed[], coverage%, flaky[]}
+  scan: {vulns[], risks{}, fixes[], compliance{}}
+  design: {arch{}, patterns[], decisions[]}
+  troubleshoot: {findings[], root_causes[], solutions[]}
+
+Reuse Rules:
+  Same target+flags: Use cache | Modified files: Invalidate
+  Chained commands: Auto-pass results | Time limit: 30min
+  Persistent patterns: Store successful workflows across sessions
+  Context sharing: Pass relevant subset→next command
+```
+
+## Advanced Context Chaining
+```yaml
+Intelligent Workflows:
+  analyze→improve: Use found issues as targets + priority ranking
+  build→test: Focus on changed modules + integration points
+  scan→fix: Prioritize critical vulnerabilities + context
+  design→build: Apply architectural patterns + decisions
+  troubleshoot→improve: Use root cause analysis for targeted fixes
+  any→deploy: Verify all checks passed + readiness assessment
+
+Context Enrichment:
+  File Change Detection: Track modifications since last analysis
+  Dependency Mapping: Understand component relationships
+  Performance Baseline: Compare against historical metrics
+  Quality Trends: Track improvement over time
+  User Patterns: Learn from successful workflows
+```
+
+## Smart Context Optimization
+```yaml
+Memory Management:
+  Essential Context: Keep critical information accessible
+  Token Optimization: Compress verbose results for efficiency
+  Selective Loading: Load only needed context per command
+  Background Processing: Precompute likely needed context
+
+Pattern Learning:
+  Workflow Recognition: Identify common command sequences
+  Success Patterns: Learn from effective approaches
+  Error Prevention: Remember failure patterns to avoid
+  User Preferences: Adapt to individual working styles
+```

package/SuperClaude/.claude/commands/shared/command-templates.yml

@@ -0,0 +1,167 @@
+# Command Templates - Token Optimized Patterns
+
+## Legend
+| Symbol | Meaning | | Abbrev | Meaning |
+|--------|---------|---|--------|---------|
+| → | leads to | | cfg | configuration |
+| & | and/with | | impl | implementation |
+| w/ | with | | perf | performance |
+| @ | at/located | | ops | operations |
+| ∀ | for all/every | | val | validation |
+| ∃ | exists/there is | | req | requirements |
+
+## Universal Command Structure Template
+
+```yaml
+Command_Header:
+  Execute: "immediately. Add --plan flag if user wants to see plan first."
+  Legend: "@command-specific legend generation"
+  Purpose: "[Action] [Subject] specified in $ARGUMENTS"
+
+Universal_Flags:
+  Planning: "@include shared/constants.yml#Standard_Flags.Planning"
+  Thinking: "@include shared/constants.yml#Standard_Flags.Thinking"
+  Compression: "@include shared/constants.yml#Standard_Flags.Compression"
+  MCP_Control: "@include shared/constants.yml#Standard_Flags.MCP_Control"
+  Execution: "@include shared/constants.yml#Standard_Flags.Execution"
+  
+Flag_Templates:
+  MCP_Control: "@see shared/mcp-flags.yml"
+  Thinking_Modes: "@see shared/thinking-modes.yml"
+  Planning_Mode: "@see shared/planning-mode.yml"
+  
+Research_Requirements:
+  Standard: "@include shared/research-first.yml#Research_Policy"
+  External_Libs: "@include shared/research-first.yml#Library_Requirements"
+  Patterns: "@include shared/research-first.yml#Pattern_Verification"
+  Citations: "@include shared/constants.yml#Standard_Messages.Report_References"
+  
+Report_Output:
+  Location: "@include shared/constants.yml#Documentation_Paths"
+  Directory: "@include shared/execution-lifecycle.yml#Preparation_Actions"
+  Reference: "@include shared/constants.yml#Standard_Messages.Report_References"
+  
+Error_Handling:
+  Classification: "@include shared/severity-levels.yml#Severity_Levels"
+  Recovery: "@include shared/error-handling.yml#Recovery_Strategies"
+  Escalation: "@include shared/severity-levels.yml#Escalation_Pathways"
+```
+
+## Command Type Templates
+
+```yaml
+Analysis_Commands:
+  Structure: "Analyze [subject] using [method]"
+  Flags: "--code --architecture --security --performance"
+  Output: "Analysis reports→.claudedocs/reports/"
+  
+Build_Commands:
+  Structure: "Build [type] w/ [requirements]"
+  Flags: "--init --feature --tdd --watch"
+  Output: "Working code + tests + docs"
+  
+Workflow_Commands:
+  Structure: "[Action] using [workflow] pattern"
+  Flags: "--dry-run --interactive --iterate"
+  Output: "Process results + metrics"
+```
+
+## Shared Flag Descriptions
+
+```yaml
+Core_Flags:
+  plan: "Show execution plan before running"
+  think: "Multi-file analysis w/ context (4K)"
+  think_hard: "Deep system analysis (10K)"
+  ultrathink: "Comprehensive analysis (32K)"
+  uc: "UltraCompressed mode (~70% token reduction)"
+  
+MCP_Flags:
+  c7: "Context7→docs & examples"
+  seq: "Sequential→complex thinking"
+  magic: "Magic→UI component generation"
+  pup: "Puppeteer→browser automation"
+  no_mcp: "Disable all MCP servers"
+  
+Quality_Flags:
+  tdd: "Test-driven development"
+  coverage: "Code coverage analysis"
+  validate: "Validation & verification"
+  security: "Security scan & audit"
+  
+Workflow_Flags:
+  dry_run: "Preview w/o execution"
+  watch: "Continuous monitoring"
+  interactive: "Step-by-step guidance"
+  iterate: "Iterative improvement"
+```
+
+## Cross-Reference System
+
+```yaml
+Instead_Of_Repeating:
+  MCP_Explanations: "@see shared/mcp-flags.yml"
+  Thinking_Modes: "@see shared/thinking-modes.yml"
+  Research_Standards: "@see shared/research-first.yml"
+  Validation_Rules: "@see shared/validation.yml"
+  Performance_Patterns: "@see shared/performance.yml"
+  
+Template_Usage:
+  Command_File: |
+    @include shared/command-templates.yml#Analysis_Commands
+    @flags shared/command-templates.yml#Core_Flags,MCP_Flags
+    
+Reference_Format: "@see [file]#[section]"
+Include_Format: "@include [file]#[section]"
+```
+
+## Token Optimization Patterns
+
+```yaml
+Compression_Rules:
+  Articles: Remove "the|a|an" where clear
+  Conjunctions: Replace "and"→"&" | "with"→"w/"
+  Prepositions: Compress "at"→"@" | "to"→"→"
+  Verbose_Phrases: "in order to"→"to" | "make sure"→"ensure"
+  
+Symbol_Expansion:
+  Mathematics: ∀(all) ∃(exists) ∈(member) ⊂(subset) ∪(union) ∩(intersection)
+  Logic: ∴(therefore) ∵(because) ≡(equivalent) ≈(approximately)
+  Process: ▶(start) ⏸(pause) ⏹(stop) ⚡(fast) 🔄(cycle)
+  Quality: ✅(success) ❌(failure) ⚠(warning) 📊(metrics)
+  
+Structure_Priority:
+  1_YAML: Most compact structured data
+  2_Tables: Comparison & reference data
+  3_Lists: Enumeration & sequences
+  4_Prose: Only when necessary
+  
+Abbreviation_Standards:
+  Technical: cfg(config) impl(implementation) perf(performance) val(validation)
+  Actions: analyze→anlz | build→bld | deploy→dply | test→tst
+  Objects: database→db | interface→api | environment→env | dependency→dep
+```
+
+## Implementation Notes
+
+```yaml
+Usage_Pattern:
+  1_Define_Template: Create in shared/command-templates.yml
+  2_Reference_Template: Use @include in command files
+  3_Override_Specific: Add command-specific details only
+  4_Validate_Consistency: Auto-check cross-references
+  
+Benefits:
+  Token_Reduction: ~40% reduction in command file size
+  Consistency: Standardized patterns across all commands
+  Maintenance: Single source of truth for common elements
+  Scalability: Easy addition of new commands using templates
+  
+Migration_Strategy:
+  Phase_1: Create templates for most common patterns
+  Phase_2: Update existing commands to use templates
+  Phase_3: Implement auto-validation of template usage
+```
+
+---
+*Command Templates v1.0 - Token-optimized reusable patterns for SuperClaude commands*