appiq-solution 1.4.8 → 1.4.9

package/#Tools/package.json

@@ -1,94 +0,0 @@
-{
-  "name": "appiq-solution",
-  "version": "1.3.0",
-  "description": "🚀 APPIQ SOLUTION: Flutter Mobile Development Extension - Eine spezialisierte Erweiterung der BMAD Method für Flutter Mobile App Entwicklung",
-  "main": "tools/cli.js",
-  "bin": {
-    "appiq-solution": "tools/bmad-npx-wrapper.js",
-    "appiq": "tools/bmad-npx-wrapper.js",
-    "bmad": "tools/bmad-npx-wrapper.js",
-    "bmad-method": "tools/bmad-npx-wrapper.js"
-  },
-  "scripts": {
-    "build": "node tools/cli.js build",
-    "build:agents": "node tools/cli.js build --agents-only",
-    "build:teams": "node tools/cli.js build --teams-only",
-    "list:agents": "node tools/cli.js list:agents",
-    "validate": "node tools/cli.js validate",
-    "install:bmad": "node tools/installer/bin/bmad.js install",
-    "format": "prettier --write \"**/*.md\"",
-    "version:patch": "node tools/version-bump.js patch",
-    "version:minor": "node tools/version-bump.js minor",
-    "version:major": "node tools/version-bump.js major",
-    "version:expansion": "node tools/bump-expansion-version.js",
-    "version:expansion:set": "node tools/update-expansion-version.js",
-    "version:all": "node tools/bump-all-versions.js",
-    "version:all:minor": "node tools/bump-all-versions.js minor",
-    "version:all:major": "node tools/bump-all-versions.js major",
-    "version:all:patch": "node tools/bump-all-versions.js patch",
-    "version:expansion:all": "node tools/bump-all-versions.js",
-    "version:expansion:all:minor": "node tools/bump-all-versions.js minor",
-    "version:expansion:all:major": "node tools/bump-all-versions.js major",
-    "version:expansion:all:patch": "node tools/bump-all-versions.js patch",
-    "release": "semantic-release",
-    "release:test": "semantic-release --dry-run --no-ci || echo 'Config test complete - authentication errors are expected locally'",
-    "prepare": "husky"
-  },
-  "dependencies": {
-    "@kayvan/markdown-tree-parser": "^1.5.0",
-    "bmad-method": "^4.30.3",
-    "chalk": "^4.1.2",
-    "commander": "^14.0.0",
-    "fs-extra": "^11.3.0",
-    "glob": "^11.0.3",
-    "inquirer": "^8.2.6",
-    "js-yaml": "^4.1.0",
-    "ora": "^5.4.1"
-  },
-  "keywords": [
-    "ai-agents",
-    "development-workflow", 
-    "project-management",
-    "flutter",
-    "mobile-development",
-    "clean-architecture",
-    "cubit",
-    "bloc",
-    "dart",
-    "greenfield",
-    "brownfield",
-    "cursor",
-    "claude-code",
-    "windsurf",
-    "agile",
-    "ai",
-    "orchestrator",
-    "development",
-    "methodology",
-    "agents",
-    "bmad"
-  ],
-  "author": "Brian (BMad) Madison",
-  "license": "MIT",
-  "repository": {
-    "type": "git", 
-    "url": "git+https://github.com/Viktor-Hermann/APPIQ-METHOD.git"
-  },
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "devDependencies": {
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/git": "^10.0.1",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.1.1",
-    "prettier": "^3.5.3",
-    "semantic-release": "^22.0.0",
-    "yaml-lint": "^1.7.0"
-  },
-  "lint-staged": {
-    "**/*.md": [
-      "prettier --write"
-    ]
-  }
-}

package/SuperClaude/.claude/commands/analyze.md

@@ -1,36 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Command_Header
-
-Multi-dimensional analysis on code, arch, or problem in $ARGUMENTS.
-
-@include shared/command-templates.yml#Universal_Flags
-@see shared/thinking-modes.yml ∀ thinking flags
-@see shared/mcp-flags.yml ∀ MCP controls
-
-Examples:
-- `/user:analyze --code --think` - Code review w/ context
-- `/user:analyze --arch --think-hard` - Deep arch analysis  
-- `/user:analyze --security --ultrathink` - Comprehensive security audit
-
-Analysis modes:
-
-**--code:** Quality review→naming, structure, DRY, complexity | Bugs→null checks, boundaries, types | Security→injection, auth, validation | Perf→O(n²), N+1, memory
-
-**--arch:** System design & patterns | Layer coupling | Scalability bottlenecks | Maintainability assessment | Improvement suggestions
-
-**--profile:** CPU, memory, execution time | Network latency, DB queries | Frontend metrics | Bottleneck identification | Optimization recommendations  
-
-**--security:** OWASP top 10 | Auth & authorization | Data handling & encryption | Attack vector identification
-
-**--perf:** Bottleneck analysis | Algorithm complexity | DB queries & indexes | Caching strategies | Resource utilization
-
-**--watch:** Continuous file monitoring | Real-time quality tracking | Auto re-analysis | Live metrics
-
-**--interactive:** Guided exploration | Step-by-step fixes | Live improvement
-
-@include shared/command-templates.yml#Research_Requirements
-
-@include shared/command-templates.yml#Report_Output
-
-Deliverables: @include shared/constants.yml#Success_Messages

package/SuperClaude/.claude/commands/build.md

@@ -1,35 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Command_Header
-
-Build project/feature based on req in $ARGUMENTS.
-
-@include shared/command-templates.yml#Universal_Flags
-@see shared/mcp-flags.yml ∀ MCP controls
-
-Examples:
-- `/user:build --react --magic` - React app w/ UI gen
-- `/user:build --api --c7` - API w/ docs
-- `/user:build --react --magic --pup` - Build & test UI
-
-Pre-build: Remove artifacts (dist/, build/, .next/) | Clean temp files & cache | Validate deps | Remove debug
-
-Build modes:
-**--init:** New project w/ stack (React|API|Fullstack|Mobile|CLI) | TS default | Testing setup | Git workflow
-**--feature:** Impl feature→existing patterns | Maintain consistency | Include tests  
-**--tdd:** Write failing tests→minimal code→pass tests→refactor
-
-Templates:
-- **React:** Vite|TS|Router|state mgmt|testing
-- **API:** Express|TS|auth|validation|OpenAPI  
-- **Fullstack:** React+Node.js+Docker
-- **Mobile:** React Native+Expo
-- **CLI:** Commander.js+cfg+testing
-
-**--watch:** Continuous build | Real-time feedback | Incremental | Live reload
-**--interactive:** Step-by-step cfg | Interactive deps | Build customization
-
-@include shared/command-templates.yml#Research_Requirements
-@include shared/execution-lifecycle.yml#Standard_Lifecycle
-
-Deliverables: @include shared/constants.yml#Success_Messages

package/SuperClaude/.claude/commands/cleanup.md

@@ -1,46 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Universal_Flags
-
-Clean up project artifacts, code & cfg specified in $ARGUMENTS.
-
---code flag:
-- Remove unused imports & dead code | Clean console.log & debug code
-- Remove commented blocks | Fix style inconsistencies | Remove TODO>30 days
-
---files flag:
-- Remove build artifacts & temp files | Clean node_modules if corrupted
-- Remove logs & cache dirs | Clean test outputs | Remove OS files (.DS_Store, thumbs.db)
-
---deps flag:
-- Remove unused deps from package.json | Update vulnerable deps
-- Clean duplicate deps | Optimize dep tree | Check outdated packages
-
---git flag:
-- Remove untracked files (w/ confirmation) | Clean merged branches
-- Remove large/unwanted files from history | Optimize git (.git/objects cleanup) | Clean stale refs
-
---cfg flag:
-- Remove deprecated cfg settings | Clean unused env vars
-- Update outdated cfg formats | Validate cfg consistency | Remove duplicate entries
-
---all flag:
-- Comprehensive cleanup all areas | Generate detailed report
-- Suggest maintenance schedule | Provide perf impact analysis
-
---dry-run flag:
-- Show what would be cleaned w/o changes | Estimate space savings & perf impact | ID risks before cleanup
-
---watch flag:
-- Monitor & auto-clean new artifacts | Continuous cleanup during dev | Prevent temp file accumulation | Real-time maintenance
-
-## Integration & Best Practices
-
-@include shared/command-templates.yml#Research_Requirements
-
-@include shared/command-templates.yml#Report_Output
-- Space savings: `.claudedocs/metrics/cleanup-savings-<timestamp>.md`
-- Ensure dirs: `mkdir -p .claudedocs/reports/ .claudedocs/metrics/`
-- Include location: "📄 Cleanup report saved to: [path]"
-
-Deliverables: Cleanup report w/ space saved, perf improvements, maintenance recommendations, safety analysis & cleanup strategy docs.

package/SuperClaude/.claude/commands/deploy.md

@@ -1,55 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Universal_Flags
-
-Deploy application to env specified in $ARGUMENTS.
-
-Thinking flags (optional):
-- --think→multi-service deployment coordination
-- --think-hard→complex infrastructure & rollback planning
-- --ultrathink→complete deployment architecture & disaster recovery
-
-Examples:
-- `/user:deploy --env staging --think` - Staging w/ coordination analysis
-- `/user:deploy --env prod --think-hard` - Prod w/ comprehensive planning
-- `/user:deploy --rollback --ultrathink` - Critical rollback w/ full impact analysis
-
-Pre-deploy cleanup:
-- Clean previous artifacts | Remove dev-only files (.env.local, debug cfgs)
-- Validate prod cfg (no debug flags, correct URLs) | Clean old versions→free space
-
---env flag:
-- dev: Deploy→dev env for testing | staging: Deploy→staging for pre-prod validation
-- prod: Deploy→prod w/ all safety checks
-
---rollback flag:
-- Revert→previous stable deployment | Maintain deployment history→audit trail
-- Verify rollback success w/ health checks
-
-Deployment workflow:
-1. Validate→Check prerequisites & cfg 2. Build→Create artifacts 3. Test→Run smoke tests
-4. Deploy→Execute strategy 5. Verify→Confirm health & functionality
-
-Deployment strategies:
-- Blue-green: Two envs, switch traffic→zero downtime | Canary: Gradual rollout→% users
-- Rolling: Update instances sequentially w/ health checks
-
-Pre-deployment checks:
-- Verify tests pass | Check deployment cfg | Ensure rollback plan exists
-- Validate env vars | Confirm DB migrations completed
-
-Post-deployment:
-- Run health checks & smoke tests | Monitor error rates & perf
-- Check critical user journeys | Verify logging & monitoring | Ready→rollback if issues
-
-## Safety & Best Practices
-
-Safety:
-- Always have rollback plan | Backups before deployment
-- Monitor key metrics during deployment | Gradual rollout→major changes
-
-@include shared/command-templates.yml#Research_Requirements
-
-@include shared/command-templates.yml#Report_Output
-
-@include shared/constants.yml#Success_Messages

package/SuperClaude/.claude/commands/design.md

@@ -1,91 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Universal_Flags
-
-Design & architect software solutions based on requirements in $ARGUMENTS.
-
-Thinking flags (optional):
-- --think→standard design patterns & component architecture
-- --think-hard→system-wide architecture & scalability planning
-- --ultrathink→complete system redesign or critical architectural decisions
-
-Examples:
-- `/user:design --api --think` - REST API design w/ patterns
-- `/user:design --ddd --think-hard` - Deep domain modeling
-- `/user:design --api --ddd --ultrathink` - Complete system architecture
-
-Design focus w/ flags:
-
---api flag:
-- Design REST or GraphQL APIs
-- w/ --openapi: Generate OpenAPI 3.0 spec | w/ --graphql: Create GraphQL schema & resolvers
-- Include auth, rate limiting & error handling | Design→scalability & maintainability
-
---ddd flag:
-- Apply DDD principles | w/ --bounded-context: Define context boundaries & mappings
-- Design entities, value objects & aggregates | Create domain services & events | Impl repository patterns
-
---prd flag:
-- Create PRD | w/ --template: Use template (feature/api/integration/migration)
-- Include user stories w/ acceptance criteria | Define success metrics & timelines | Document tech requirements
-
-## API Design Mode (--api)
-
-REST API principles:
-- Resource-oriented URLs w/ proper HTTP verbs | Consistent status codes & error formats
-- Versioning strategy (URL/header/accept) | Pagination, filtering & sorting | HATEOAS→discoverability | OpenAPI docs
-
-GraphQL principles:
-- Clear type system w/ schemas | Efficient queries & mutations | Real-time subscriptions where needed
-- DataLoader patterns→N+1 prevention | Field-level auth | Error handling practices
-
-Common API elements:
-- Auth (JWT/OAuth/API keys) | Rate limiting & throttling | Request/response validation
-- Caching strategies | CORS & security headers | Monitoring & logging
-
-## DDD Mode (--ddd)
-
-Building blocks:
-- **Entities**: Objects w/ unique identity | **Value Objects**: Immutable objects by attributes
-- **Aggregates**: Consistency boundaries w/ roots | **Domain Services**: Business logic not in entities
-- **Repositories**: Abstract data access | **Domain Events**: Capture business events
-
-Strategic patterns:
-- Bounded contexts w/ clear boundaries | Context mapping (shared kernel, anti-corruption layer)
-- Ubiquitous language within contexts | Event-driven architecture | CQRS where appropriate
-
-Structure:
-```
-domain/          # Core business logic
-application/     # Use cases & orchestration  
-infrastructure/  # External concerns
-presentation/    # UI/API layer
-```
-
-## PRD Mode (--prd)
-
-Structure:
-1. **Executive Overview**: Problem statement & solution | Expected impact & ROI | Key stakeholders
-2. **Goals & Success Metrics**: Primary objectives (must-have) | Secondary goals (nice-to-have) | KPIs & measurement
-3. **User Stories & Requirements**: User personas & journeys | Functional requirements | Non-functional requirements | Acceptance criteria
-4. **Technical Specs**: Architecture overview | Tech choices | Integration points | Security requirements | Perf targets  
-5. **Timeline & Risks**: Dev phases | Dependencies & blockers | Risk mitigation strategies
-
-## Integration
-
-Combined modes:
-- API+DDD: Design domain-driven APIs | API+PRD: Create API product requirements
-- DDD+PRD: Document domain-driven architecture | All three: Complete system design
-
-Best practices:
-- Start w/ user needs & business goals | Design→change & evolution | Consider non-functional early
-- Document decisions & rationale | Include examples & diagrams | Plan→testing & monitoring
-
-Research requirements:
-- Architecture patterns→C7 & industry practices | API standards→reference OpenAPI/REST/GraphQL specs
-- DDD patterns→verify w/ Evans' book or official DDD | Tech choices→WebSearch recent comparisons & case studies
-- Never design on assumptions - verify patterns | All decisions cite authoritative sources
-
-Deliverables:
-- API: Complete spec, impl guide, docs | DDD: Domain model, bounded contexts, architecture diagrams, code structure
-- PRD: Requirements doc, user stories, success metrics, timeline

package/SuperClaude/.claude/commands/dev-setup.md

@@ -1,37 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Universal_Flags
-
-Setup comprehensive dev env or CI/CD pipeline based on $ARGUMENTS.
-
-Thinking flags (optional):
-- --think→multi-tool env coordination
-- --think-hard→complex CI/CD pipeline architecture  
-- --ultrathink→enterprise dev infrastructure design
-
-Examples:
-- `/user:dev-setup --install --think` - Tool installation w/ dependency analysis
-- `/user:dev-setup --ci --think-hard` - CI/CD pipeline w/ comprehensive workflow design
-- `/user:dev-setup --monitor --ultrathink` - Complete observability infrastructure
-
---install flag:
-- Install & cfg dev tools (Node.js, Git, Docker, DBs) | Setup IDE cfgs→consistent dev experience
-- Create npm scripts→common tasks | Cfg pre-commit hooks→code quality | Setup linting & testing frameworks
-
---ci flag:
-- Cfg CI/CD pipelines (GitHub Actions, GitLab CI, other platforms) | Setup build, test & deployment stages
-- Cfg envs: dev, staging & prod | Add security scanning & dep checking | Setup deployment automation
-
---monitor flag:
-- Cfg observability tools | Setup logging & monitoring | Add perf tracking
-- Cfg error reporting | Setup alerts→critical issues
-
-## Best Practices & Security
-
-Ensure all cfgs follow security practices & include comprehensive docs.
-
-@include shared/command-templates.yml#Research_Requirements
-
-@include shared/command-templates.yml#Report_Output
-
-@include shared/constants.yml#Success_Messages

package/SuperClaude/.claude/commands/document.md

@@ -1,99 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Universal_Flags
-
-Create comprehensive docs for code, API, or system specified in $ARGUMENTS.
-
-Flags:
-- --api: Generate API docs | --user: Generate user-friendly guides
-- --ultracompressed, --uc: Generate docs w/ ~70% fewer tokens using telegram-style
-
---api flag:
-- Document all endpoints w/ examples | Include request/response formats
-- Specify auth requirements | Document error codes & meanings | Add rate limiting info | Provide code samples→multiple languages
-
---user flag:
-- Create user-friendly guides | Include step-by-step tutorials | Add screenshots or diagrams
-- Write FAQ section | Include troubleshooting guide | Provide real-world examples
-
-Documentation types:
-
-README Documentation:
-- Project overview and purpose
-- Installation instructions
-- Quick start guide
-- Configuration options
-- Basic usage examples
-- Contributing guidelines
-
-Architecture Documentation:
-- System design overview
-- Component relationships
-- Data flow diagrams
-- Technology choices rationale
-- Scalability considerations
-- Security architecture
-
-API Documentation:
-- Endpoint descriptions
-- HTTP methods and status codes
-- Request/response schemas
-- Authentication methods
-- Example requests with curl/code
-- Webhook documentation
-- WebSocket events (if applicable)
-
-User Guides:
-- Getting started tutorial
-- Feature walkthroughs
-- Best practices guide
-- Common use cases
-- Integration guides
-- Migration guides
-
-Developer Documentation:
-- Code structure overview
-- Development setup
-- Testing guidelines
-- Deployment process
-- Debugging tips
-- Performance optimization
-
-Documentation standards:
-- Use clear, concise language
-- Include practical examples
-- Add visual aids where helpful
-- Keep information current
-- Make it searchable
-- Version-specific when needed
-- Test all code examples
-
-When --ultracompressed flag is present:
-- Apply shared/ultracompressed.yml rules
-- Generate legend at doc start
-- Remove articles, conjunctions, fillers
-- Use symbols: →&@+- w/ w/o
-- Use abbreviations: cfg fn impl req resp
-- Headings <20 chars, sentences <50 chars
-- Format: YAML>JSON>prose, tables>lists>paragraphs
-- Target ~70% token reduction
-
-Structure guidelines:
-- Logical organization
-- Progressive disclosure
-- Cross-references
-- Glossary for terms
-- Index for quick lookup
-- Change log maintenance
-
-Documentation Output:
-- API documentation: `/docs/api/`
-- User guides: `/docs/guides/`
-- Architecture docs: `/docs/architecture/`
-- Developer docs: `/docs/development/`
-- README files: `/docs/README.md` (main), subdirectory READMEs as needed
-- Ensure directory exists: `mkdir -p /docs/[category]/`
-- Include location in output: "📚 Documentation created: [path]"
-- Update `/docs/index.md` with new documentation links
-
-Deliverables: Complete documentation matching the specified type, working code examples, visual aids or diagrams as needed, and quick reference guide.

package/SuperClaude/.claude/commands/estimate.md

@@ -1,69 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Universal_Flags
-
-Provide comprehensive time & complexity estimates for task in $ARGUMENTS.
-
-Thinking flags (optional):
-- --think→multi-component estimation w/ deps
-- --think-hard→complex project estimation w/ risk analysis
-- --ultrathink→enterprise-scale estimation w/ full uncertainty modeling
-
-Examples:
-- `/user:estimate --detailed --think` - Detailed breakdown w/ dependency analysis
-- `/user:estimate --worst-case --think-hard` - Risk-based estimation w/ comprehensive scenarios
-- `/user:estimate "migrate to microservices" --ultrathink` - Complex architectural estimation
-
-Relevant factors:
-
-Time components:
-- Dev time→impl | Code review & feedback cycles | Testing (unit, integration, E2E)
-- Deployment & verification | Docs updates
-
-Complexity multipliers:
-- New feature from scratch: 1x baseline | Refactoring existing: 1.5x (understanding + changing)
-- Working w/ legacy: 2x (constraints + unknowns) | Cross-team deps: 1.5x (coordination overhead)
-
-Uncertainty factors:
-- Clear requirements, known tech: ±10%
-- Some unknowns, new patterns: ±25%
-- Significant unknowns, research needed: ±50%
-- Completely new territory: ±100%
-
-Estimation workflow:
-1. Break down task into subtasks
-2. Estimate each subtask individually
-3. Apply complexity multipliers
-4. Add appropriate uncertainty buffer
-5. Provide a realistic range, not a single number
-
-Formula: Base time × Complexity × Uncertainty = Time range
-
-Include in estimates:
-- Best case scenario (everything goes smoothly)
-- Realistic case (normal friction and discoveries)
-- Worst case scenario (significant obstacles)
-
-## Additional Considerations
-
-Context factors:
-- Developer experience level with the codebase
-- Availability of documentation and examples
-- Required coordination with other teams
-- Potential blockers or dependencies
-
-Research requirements for estimation:
-- Technology patterns → Research implementation complexity via C7 and official docs
-- Architecture patterns → WebSearch for similar project timelines and case studies
-- Team velocity → Check historical data and industry benchmarks
-- Risk assessment → Must verify common pitfalls and mitigation strategies
-- Never estimate based on gut feeling - always research comparable scenarios
-- All estimates must cite sources: // Source: [estimation data reference]
-
-Report Output:
-- Estimate summaries: `.claudedocs/summaries/estimate-<timestamp>.md`
-- Risk assessments: `.claudedocs/reports/risk-analysis-<timestamp>.md`
-- Ensure directory exists: `mkdir -p .claudedocs/summaries/ .claudedocs/reports/`
-- Include report location in output: "📄 Estimate saved to: [path]"
-
-Deliverables: Time estimate range (min-max), complexity assessment, required resources, key assumptions, risk analysis, and potential blockers that could affect the estimate.

package/SuperClaude/.claude/commands/explain.md

@@ -1,85 +0,0 @@
-@include shared/constants.yml#Process_Symbols
-
-@include shared/command-templates.yml#Universal_Flags
-
-Provide comprehensive explanations of concepts, code, or systems in $ARGUMENTS.
-
-Thinking flags (optional):
-- --think→multi-concept explanation w/ connections
-- --think-hard→complex system explanations w/ deep analysis
-- --ultrathink→comprehensive knowledge synthesis & teaching
-
-MCP flags (optional):
-- --c7→fetch official lib/framework docs | --seq→step-by-step concept breakdown
-- --no-mcp→explain using only codebase context
-
-Doc flags:
-- --ultracompressed or --uc→7 0% token reduction in explanations
-
-Examples:
-- `/user:explain --c7 "React hooks" --think` - React hooks w/ contextual connections
-- `/user:explain --seq "OAuth flow" --think-hard` - Deep OAuth analysis w/ security implications
-- `/user:explain --depth advanced --c7 --ultrathink` - Comprehensive system explanation
-
---depth flag levels:
-- ELI5: Simple analogies, avoid jargon, focus→concepts
-- Beginner: Cover basics, step-by-step guidance, simple examples
-- Intermediate: Tech details, best practices, common patterns
-- Expert: Deep impl details, edge cases, perf considerations
-
-When --visual flag is present:
-- Create diagrams using Mermaid syntax
-- Use ASCII art for simple visualizations
-- Include flowcharts for processes
-- Add sequence diagrams for interactions
-
-Structure the explanation:
-1. Start with a high-level overview
-2. Break down into logical components
-3. Explain each component with appropriate depth
-4. Show relationships and interactions
-5. Provide concrete examples
-
-Include relevant formats:
-- Code examples that can be run and tested
-- Comparison tables for alternatives
-- Pros and cons lists for decisions
-- Links to authoritative resources
-
-For technical concepts:
-- Explain the "what" before the "how"
-- Connect to familiar concepts when possible
-- Build understanding incrementally
-- Address common misconceptions
-
-For code explanations:
-- Walk through logic step by step
-- Explain design decisions
-- Highlight important patterns
-- Point out potential gotchas
-
-## UltraCompressed Mode
-
-When --ultracompressed flag is present:
-- Apply shared/ultracompressed.yml rules
-- Generate legend for symbols/abbreviations used
-- Compress explanations to ~30% of normal size
-- Use telegram-style: remove articles, use symbols
-- Format: lists>paragraphs, tables>prose
-- Example: "fn takes 3 params→bool" instead of "The function takes three parameters and returns a boolean value"
-
-Research requirements for explanations:
-- Technical concepts → C7 documentation for authoritative explanations and examples
-- Framework patterns → Must verify with official guides and documentation
-- Best practices → WebSearch for current industry standards and expert opinions
-- Code examples → Research working patterns from official documentation
-- Never explain without verification - always cite authoritative sources
-- All explanations must include sources: // Source: [documentation reference]
-
-Report Output:
-- Explanation summaries: `.claudedocs/summaries/explanation-<topic>-<timestamp>.md`
-- Learning resources: `.claudedocs/reports/learning-resources-<timestamp>.md`
-- Ensure directory exists: `mkdir -p .claudedocs/summaries/ .claudedocs/reports/`
-- Include report location in output: "📚 Explanation saved to: [path]"
-
-Deliverables: Clear explanation at the appropriate depth level, working examples, visual aids if requested, curated resources for further learning, and comprehensive source references.