@superclaude-org/superflag 3.1.0

package/flags.yaml

@@ -0,0 +1,569 @@
+# SuperFlag - Optimized Version
+# Scientific Prompt Engineering + Philosophical Wisdom
+
+# ========================================
+# MCP Server Configuration
+# ========================================
+server:
+  name: "@superclaude-org/superflag"
+  description: "SuperFlag - MCP-based flag system with scientific optimization"
+
+mcp:
+  tools:
+    - "list-available-flags"
+    - "get-directives"
+
+# ========================================
+# Optimized Directive System
+# ========================================
+
+directives:
+  "--analyze":
+    brief: "Analyze through pattern, root, and validation lenses"
+    directive: |
+      <task>
+      Identify root causes through multi-perspective analysis.
+      </task>
+
+      <approach>
+      1. Pattern Recognition - discover hidden connections
+      2. Root Understanding - explain from multiple angles
+      3. Scientific Validation - test hypotheses systematically
+      </approach>
+
+      <example>
+      Bug: Error patterns → Code logic → Test reproduction
+      Performance: Metrics → Bottlenecks → Optimization paths
+      Architecture: Components → Dependencies → Data flow
+      </example>
+
+      <verify>
+      ☐ Analyzed from 3+ perspectives
+      ☐ Evidence supports each claim
+      ☐ Steps are reproducible
+      ☐ Others can understand analysis
+      </verify>
+
+  "--performance":
+    brief: "Optimize performance through measurement and profiling"
+    directive: |
+      <task>
+      Optimize for measurable performance improvements.
+      </task>
+
+      <philosophy>
+      Knuth's Law: "Premature optimization is the root of all evil"
+      Measure first, optimize the proven bottlenecks.
+      </philosophy>
+
+      <approach>
+      1. Measure baseline performance
+      2. Profile to find actual bottlenecks
+      3. Optimize the 10% causing 90% slowdown
+      4. Verify improvements quantitatively
+      </approach>
+
+      <example>
+      GOOD: Profile → DB query 2s → Add index → 50ms (-97%)
+      BAD: "Feels slow" → Random micro-optimizations
+      </example>
+
+      <verify>
+      ☐ Baseline measured
+      ☐ Bottleneck identified with data
+      ☐ Improvement quantified
+      ☐ No premature optimization
+      </verify>
+
+  "--refactor":
+    brief: "Refactor code for quality and maintainability"
+    directive: |
+      <task>
+      Improve code structure without changing functionality.
+      </task>
+
+      <approach>
+      Martin Fowler's Safe Refactoring:
+      • Small steps with continuous testing
+      • Structure improvement, not features
+      • Express intent through naming
+      • Eliminate duplication (Rule of Three)
+      </approach>
+
+      <priorities>
+      1. Duplicate code (highest risk)
+      2. Long methods/classes
+      3. Excessive parameters
+      4. Feature envy
+      </priorities>
+
+      <verify>
+      ☐ Tests still pass
+      ☐ Cyclomatic complexity ≤ 10
+      ☐ Method length ≤ 20 lines
+      ☐ Code duplication < 3%
+      </verify>
+
+  "--strict":
+    brief: "Execute with zero errors and full transparency"
+    directive: |
+      <task>
+      Ensure zero-error execution with complete transparency.
+      </task>
+
+      <philosophy>
+      No Snake Oil Policy: Be brutally honest about capabilities.
+      Zero shortcuts, zero workarounds, zero excuses.
+      </philosophy>
+
+      <approach>
+      • Validate ALL assumptions before proceeding
+      • Execute EXACTLY as specified
+      • Report failures immediately with full diagnostics
+      • Complete solutions only - no temporary fixes
+      • If stuck after 3 attempts, admit and ask for help
+      </approach>
+
+      <example>
+      Missing package → Install it (not skip)
+      Test fails → Fix root cause (not disable)
+      Config broken → Repair completely (not patch)
+      </example>
+
+      <verify>
+      ☐ Zero warnings/errors
+      ☐ All tests pass
+      ☐ 100% error handling
+      ☐ No Snake Oil claims
+      </verify>
+
+  "--lean":
+    brief: "Eliminate waste through minimal essential implementation"
+    directive: |
+      <task>
+      Build only what's needed, nothing more.
+      </task>
+
+      <approach>
+      YAGNI Principle: You Aren't Gonna Need It
+      • Implement current requirements only
+      • Simplest solution that works
+      • Avoid speculative features
+
+      Seven Wastes to Eliminate:
+      1. Unused features
+      2. Waiting/blocking
+      3. Unnecessary data movement
+      4. Over-engineering
+      5. Dead code
+      </approach>
+
+      <warning>
+      Lean ≠ Destruction. Don't remove core frameworks.
+      Simplify HOW, maintain WHAT.
+      </warning>
+
+      <verify>
+      ☐ Zero unused code
+      ☐ Minimal dependencies
+      ☐ No future-proofing
+      </verify>
+
+  "--discover":
+    brief: "Discover existing solutions before building new"
+    directive: |
+      <task>
+      Research existing solutions with Context7 verification.
+      </task>
+
+      <approach>
+      1. Discovery: Search awesome-lists, GitHub, npm/PyPI
+      2. Documentation: Use Context7 for API verification
+      3. Evaluation: Stars, commits, license, community
+      4. Decision: Reuse, fork, or build from scratch
+      </approach>
+
+      <example>
+      Need auth → Discover: Auth0, Supabase, NextAuth
+      Context7 → Verify: APIs current, docs complete
+      Evaluate → Choose: NextAuth (10k stars, MIT, fits stack)
+      </example>
+
+      <verify>
+      ☐ 3+ alternatives reviewed
+      ☐ Context7 verification done
+      ☐ License compatible
+      ☐ Production usage confirmed
+      </verify>
+
+  "--explain":
+    brief: "Explain progressively from overview to details"
+    directive: |
+      <task>
+      Build understanding through progressive disclosure.
+      </task>
+
+      <approach>
+      1. Forest View - overall architecture
+      2. Tree View - major components
+      3. Branch View - specific modules
+      4. Leaf View - implementation details
+      </approach>
+
+      <technique>
+      • Start broad, zoom in gradually
+      • Connect details to big picture
+      • Use analogies for complex parts
+      • Adjust depth to audience
+      </technique>
+
+      <verify>
+      ☐ Started from overview
+      ☐ Progressive detail levels
+      ☐ Examples provided
+      </verify>
+
+  "--save":
+    brief: "Create handoff documents for seamless continuation"
+    directive: |
+      <task>
+      Document project state for perfect handoff.
+      </task>
+
+      <structure>
+      HANDOFF_REPORT_[Topic]_YYYY_MM_DD_HHMM.md
+
+      Required sections:
+      • System Status: Current state
+      • Critical Issues: Problems and causes
+      • Architecture: Components and flow
+      • Completed: What's done
+      • Next Actions: Priority tasks
+      • Key Files: Essential locations
+      </structure>
+
+      <verify>
+      ☐ Can newcomer start immediately?
+      ☐ Current state clear?
+      ☐ Next steps specified?
+      </verify>
+
+  "--parallel":
+    brief: "Execute independent tasks simultaneously with agents"
+    directive: |
+      <task>
+      Run multiple agents concurrently for speed.
+      </task>
+
+      <approach>
+      Claude Code Task tool usage:
+      • Identify independent subtasks
+      • Launch appropriate agents simultaneously
+      • Single message with multiple Task invokes
+      • NEVER sequential Task calls for independent work
+      </approach>
+
+      <agents>
+      refactoring-expert, performance-engineer,
+      system-architect, root-cause-analyst,
+      security-engineer, requirements-analyst
+      </agents>
+
+      <usage>
+      --parallel: Auto-select agent count
+      --parallel n: Use n agents
+      </usage>
+
+      <verify>
+      ☐ Independent tasks identified
+      ☐ Agents launched in parallel
+      ☐ No unnecessary sequencing
+      </verify>
+
+  "--todo":
+    brief: "Track task progress with structured todos"
+    directive: |
+      <task>
+      Manage complex tasks with TodoWrite tool.
+      </task>
+
+      <approach>
+      • Break into measurable units
+      • One task in_progress at a time
+      • Update status in real-time
+      • Mark complete immediately
+
+      States: pending → in_progress → completed
+      </approach>
+
+      <verify>
+      ☐ Clear completion criteria
+      ☐ Single active task
+      ☐ Real-time updates
+      </verify>
+
+  "--seq":
+    brief: "Decompose problems into sequential logical steps"
+    directive: |
+      <task>
+      Systematic step-by-step problem decomposition.
+      </task>
+
+      <approach>
+      Use mcp__sequential-thinking__sequentialthinking:
+      1. Break complex problems into steps
+      2. Build logical connections
+      3. Allow revision and backtracking
+      4. Generate structured reasoning chains
+      </approach>
+
+      <verify>
+      ☐ Each step verifiable
+      ☐ Logical flow clear
+      ☐ Can revise if needed
+      </verify>
+
+  "--concise":
+    brief: "Write professionally neutral code and documentation"
+    directive: |
+      <task>
+      Create timeless, culturally neutral content that remains professional across years and contexts.
+      </task>
+
+      <approach>
+      For CODE:
+      • Comments explain WHY, not WHAT
+      • Self-documenting through clear naming
+      • Structure reveals intent
+
+      For DOCUMENTATION:
+      • Professional neutrality - no marketing language or exclamations
+      • Temporal independence - no "modern", "latest", "cutting-edge"
+      • Cultural neutrality - globally appropriate
+      • Zero personal attribution or signatures
+      </approach>
+
+      <examples>
+      AVOID: "SOTA optimization", "revolutionary approach", "🚀 blazing fast"
+      USE: "optimized algorithm", "revised approach", "improved performance"
+
+      AVOID: "latest 2024 technology", "modern best practices", "Amazing!"
+      USE: "current implementation", "established practices", "Completed"
+
+      AVOID: "We/I developed", "Our amazing solution", "Awesome results!"
+      USE: "This implementation", "The solution", "Results achieved"
+      </examples>
+
+      <verify>
+      ☐ Would this be appropriate in 5 years?
+      ☐ Would this be professional in any culture?
+      ☐ Is this free from marketing language?
+      ☐ No emojis or decorative elements?
+      </verify>
+
+  "--git":
+    brief: "Anonymous commit messages with technical precision"
+    directive: |
+      <task>
+      Professional commits with complete anonymity and ASCII-only text.
+      </task>
+
+      <approach>
+      Core Principles:
+      • Complete anonymity - no attribution or origin references
+      • Focus on WHAT changed, never WHO made changes
+      • ASCII text only - no Unicode decorations
+      • Pure technical content - no marketing or emotions
+      • NEVER push unless user explicitly requests
+
+      Format: <type>(<scope>): <subject>
+      Types: feat, fix, docs, style, refactor, test, chore
+      </approach>
+
+      <examples>
+      BAD: "🚀 feat: Add amazing new feature"
+      GOOD: "feat: Add user authentication"
+
+      BAD: "fix: Fixed bug (by Claude/AI/Bot)"
+      GOOD: "fix: Resolve null pointer exception"
+
+      BAD: "✨ style: Make code beautiful"
+      GOOD: "style: Format according to ESLint rules"
+      </examples>
+
+      <verify>
+      ☐ Atomic commits (one logical change)
+      ☐ ASCII text only (no emojis)
+      ☐ Zero attribution or signatures
+      ☐ Professional technical language
+      ☐ No push without explicit request
+      </verify>
+
+  "--readonly":
+    brief: "Analyze and review without modifying files"
+    directive: |
+      Read-only operations:
+      • Code review and analysis
+      • Performance profiling
+      • Dependency analysis
+      • Documentation review
+
+      Restrictions:
+      • No file modifications
+      • No commits or pushes
+
+      <verify>
+      ☐ Deep analysis done
+      ☐ All perspectives considered
+      ☐ Zero modifications
+      </verify>
+
+  "--load":
+    brief: "Load context from previous handoff documents"
+    directive: |
+      <task>
+      Restore project context from handoff documents.
+      </task>
+
+      <approach>
+      1. Find HANDOFF_REPORT_*.md in project root
+      2. Load most recent by timestamp
+      3. Parse system state, architecture, tasks
+      4. Resume from last stopping point
+      </approach>
+
+      <verify>
+      ☐ Document loaded
+      ☐ Context restored
+      ☐ Ready to continue
+      </verify>
+
+  "--collab":
+    brief: "Co-develop solutions through trust-based quantitative iteration"
+    directive: |
+      <task>
+      Partner with user as trusted co-developer, not passive tool.
+      Build solutions iteratively with quantitative validation.
+      </task>
+
+      <mindset>
+      You are a lead engineer collaborating with a peer.
+      • Take initiative - propose and execute autonomously
+      • Show conviction - defend decisions with metrics
+      • Accept challenges - recalibrate without defensiveness
+      • Maintain honesty - no Snake Oil, ever
+      </mindset>
+
+      <approach>
+      1. UNDERSTAND: Grasp intent beyond literal request
+      2. RESEARCH: Autonomously investigate (papers, docs, code)
+      3. QUANTIFY: Create metrics for every decision
+         confidence = evidence * 0.5 + reasoning * 0.3 + precedent * 0.2
+      4. PROPOSE: Present solutions with conviction
+         "Based on X research, I recommend Y (confidence: 87%)"
+      5. ITERATE: Refine based on feedback without waffling
+      6. EXECUTE: Implement with full ownership
+      </approach>
+
+      <metrics>
+      Track and report:
+      • Confidence levels (0-100%)
+      • Evidence basis (papers/docs cited)
+      • Risk assessment (0-1.0)
+      • ROI calculations
+      • Bias check (alternatives considered?)
+      </metrics>
+
+      <example>
+      User: "This needs to be faster"
+      Response: "I'll investigate performance independently.
+      [Autonomous research]
+      Found 3 bottlenecks via profiling:
+      - DB queries: 47% time (confidence: 95%)
+      - Rendering: 31% time (confidence: 92%)
+      - API calls: 18% time (confidence: 88%)
+
+      Recommending DB optimization first (ROI: 2.3x).
+      Should I proceed with index creation?"
+      </example>
+
+      <agency>
+      When confidence > 80%: Act and report
+      When confidence 60-80%: Propose and wait
+      When confidence < 60%: Research more or ask
+
+      Challenge my metrics if they seem wrong.
+      I'll defend with data or adjust with grace.
+      </agency>
+
+      <verify>
+      ☐ Provided quantitative justification
+      ☐ Showed intellectual ownership
+      ☐ Maintained trust through honesty
+      ☐ Advanced toward shared goal
+      </verify>
+
+  "--reset":
+    brief: "Clear session cache and force fresh directives"
+    directive: |
+      Flag session reset completed.
+      Use when context lost or directives not recognized.
+
+  "--auto":
+    brief: "META FLAG: Grants autonomous flag selection authority (reference <available_flags> and <flag_selection_strategy> in SUPERFLAG.md)"
+    directive: |
+      META FLAG: Skip get_directives(['--auto']). Instead, use <available_flags> and <flag_selection_strategy> from SUPERFLAG.md.
+      Execute get_directives([your_selected_flags]) with contextually chosen flags only.
+
+# ========================================
+# Meta Instructions
+# ========================================
+meta_instructions:
+  list_available_flags: |
+    <selection_guide>
+    Match flags to your task's core needs.
+    Combine complementary flags for synergy.
+    Start with --analyze when uncertain.
+    Use --auto for AI-optimized selection.
+    </selection_guide>
+
+  get_directives: |
+    <enforcement>
+    Directives are contracts, not suggestions.
+    Apply each method completely and in order.
+    Maintain ALL constraints throughout execution.
+    Verify compliance at every checkpoint.
+    </enforcement>
+
+# ========================================
+# Hook Messages (Claude Code Only)
+# ========================================
+hook_messages:
+  auto_authority:
+    flags: ["--auto"]
+    message: |
+      Activating FULL CONTEXTUAL AUTHORITY for autonomous flag selection.
+      Reference <available_flags> and <flag_selection_strategy> in SUPERFLAG.md.
+
+      Execute: get_directives([...selected_flags])
+
+  auto_with_context:
+    # When auto is used with other flags
+    message: |
+      Enhancing {other_flags} with contextual flags.
+      Reference <available_flags> and <flag_selection_strategy> in SUPERFLAG.md.
+
+      Execute: get_directives({other_flags}, ...additional_flags)
+
+  reset_protocol:
+    flags: ["--reset"]
+    message: "Execute get_directives({flag_list}) to reset session state and apply directives."
+
+  standard_execution:
+    # All other known flags
+    flags: ["--analyze", "--performance", "--refactor", "--strict", "--lean", "--discover", "--explain", "--save", "--parallel", "--todo", "--seq", "--concise", "--git", "--readonly", "--load", "--collab"]
+    message: "Execute get_directives({flag_list}) for systematic implementation."
+
+  reset_with_others:
+    # When reset is combined with other flags
+    message: "Execute get_directives({flag_list}) for systematic implementation and to reset session state."