midas-mcp 1.0.0

package/dist/docs/METHODOLOGY.md

@@ -0,0 +1,334 @@
+# Elite Vibecoding Methodology
+
+The complete methodology that Midas teaches and enforces.
+
+## Core Philosophy
+
+**Vibecoding** = Using AI as a pair programmer, not a replacement. You drive the vision, AI handles implementation.
+
+**The 80/20 Rule:** AI handles ~80% of boilerplate and patterns. You handle the 20% that requires judgment, architecture, and domain knowledge.
+
+**The Genie Mindset:** You have a genie. It will build anything — if you learn how to ask.
+
+---
+
+## The Two Phases
+
+### Phase 1: Eagle Sight (Pre-Build)
+
+```
+💡 IDEA → 🔍 RESEARCH → 🧠 BRAINLIFT → 📋 PRD → 🗺️ GAMEPLAN → ⚡ BUILD
+```
+
+| Step | What It Is | Time |
+|------|------------|------|
+| 💡 Idea | The spark — what and why | 5 min |
+| 🔍 Research | Landscape scan — what exists | 30-60 min |
+| 🧠 Brainlift | Your edge — what AI doesn't know | 15-30 min |
+| 📋 PRD | Requirements — what exactly to build | 30-60 min |
+| 🗺️ Gameplan | Strategy — how to build it | 15-30 min |
+
+**Total: 2-3 hours** → Saves 20-40 hours of confused building
+
+#### Brainlift Template
+
+```markdown
+# Brainlift
+
+## Contrarian Insights
+- [What do YOU know that contradicts conventional wisdom?]
+- [What have you learned from experience that AI can't know?]
+
+## Domain Knowledge
+- [Industry-specific context]
+- [User behavior patterns you've observed]
+
+## Hard-Won Lessons
+- [What NOT to do based on past experience]
+- [Hidden gotchas in this space]
+
+## Current Context
+- [Recent market changes]
+- [Technology updates post-training-cutoff]
+```
+
+#### PRD Template
+
+```markdown
+# PRD: [Project Name]
+
+## Overview
+[One-paragraph description]
+
+## Goals
+1. [Primary goal]
+2. [Secondary goal]
+
+## Non-Goals (Equally Important!)
+- [What you're explicitly NOT building]
+
+## User Stories
+- As a [user type], I want to [action] so that [benefit]
+
+## Technical Requirements
+- [Performance, security, integration requirements]
+
+## Success Metrics
+- [How you'll measure success]
+```
+
+#### Gameplan Template
+
+```markdown
+# Gameplan: [Project Name]
+
+## Tech Stack
+[Stack choice with justification]
+
+## Architecture Overview
+[High-level system design]
+
+## Phase 1: Foundation
+- [ ] Task 1
+- [ ] Task 2
+
+## Phase 2: Core Features
+- [ ] Task 1
+- [ ] Task 2
+
+## Risk Mitigation
+- Risk: [issue] → Mitigation: [solution]
+```
+
+---
+
+### Phase 2: The 7-Step Process (Build)
+
+```
+        ▲
+       /░\        1. USER RULES (.cursorrules)
+      /░░░\           (Identity + Guardrails)
+     /▓▓▓▓▓\      2. INDEX CODEBASE STRUCTURE
+    /▓▓▓▓▓▓▓\         (Architecture Context)
+   /▒▒▒▒▒▒▒▒▒\    3. READ SPECIFIC FILES
+  /▒▒▒▒▒▒▒▒▒▒▒\       (Implementation Details)
+ /█████████████\  4. RESEARCH DOCS + ONLINE
+/███████████████\     (External Knowledge)
+       ↓
+5. WRITE CODE + TESTS → 6. RUN TESTS → 7. LOG → FIX → REPEAT
+```
+
+Each layer builds on the one above. You can't skip layers.
+
+---
+
+## The Three Principles
+
+### 1. Oneshot Paradigm
+
+When something breaks, **go back with full context** instead of patching forward.
+
+```
+❌ Prompt → Broken → Fix → More broken → Fix → Chaos
+✅ Prompt → Broken → STOP → Original prompt + error log → Works
+```
+
+**The Formula:**
+```
+[Original Prompt] + [Error Log] + [What to Avoid] = Working Solution
+```
+
+**The 3-Strike Rule:**
+```
+Strike 1: "Fix this" → Still broken
+Strike 2: "Try this" → Different error  
+Strike 3: "What about..." → Even more broken
+STOP! → Oneshot with full context → Works
+```
+
+### 2. Tornado Building
+
+Three forces spinning together solve any problem:
+
+```
+         ┌─────────────┐
+         │  RESEARCH   │
+         │  + DOCS     │
+         └──────┬──────┘
+                │
+    ╭───────────┼───────────╮
+   ╱            │            ╲
+┌──────────┐    │    ┌──────────┐
+│   LOGS   │◄───┴───►│   TESTS  │
+└────┬─────┘         └────┬─────┘
+     │                    │
+     ╰────────┬───────────╯
+              ▼
+     ┌─────────────────┐
+     │ SOLUTION EMERGES│
+     └─────────────────┘
+```
+
+Each feeds the others:
+- RESEARCH → informs what to LOG → informs what to TEST
+- Test failures → inform more RESEARCH
+
+### 3. Horizon Thinking
+
+AI thinks **vertical** (top-to-bottom implementation).
+You provide **horizontal** (context, patterns, constraints).
+
+```
+                          YOU
+                           │
+     ◄─────────────────────┼─────────────────────►  HORIZONTAL
+                           │
+     Patterns              │              Constraints
+     History               │              Integrations
+     Domain Knowledge      │              Future Plans
+                           │
+                          ─┼─
+                           │
+                           │  AI
+                           ▼  VERTICAL
+```
+
+**Wrong output? Widen your horizontal context.**
+
+The Horizon Checklist:
+```
+□ INTEGRATIONS   "This connects to [existing system]"
+□ PATTERNS       "Follow the pattern in [file]"
+□ CONSTRAINTS    "Cannot use [limitation]"
+□ HISTORY        "We use X because [reason]"
+□ FUTURE         "Must support [planned feature] later"
+□ DOMAIN         "Users typically [behavior]"
+```
+
+---
+
+## Context Management
+
+### The Context Pyramid
+
+```
+Layer 1: USER RULES      (Identity + Guardrails)
+Layer 2: CODEBASE        (Architecture Context)
+Layer 3: SPECIFIC FILES  (Implementation Details)
+Layer 4: RESEARCH        (External Knowledge)
+```
+
+### When to Start Fresh
+
+- After shipping a feature (clean slate)
+- AI keeps making the same mistake
+- Switching to unrelated work
+- Responses get confused/repetitive
+
+### Bringing Context into New Chats
+
+1. Reference user rules first
+2. Point to specific files with `@filename`
+3. Provide horizontal context (patterns, constraints)
+4. Summarize previous decisions
+
+---
+
+## AI Strengths vs Your Job
+
+### Let AI Handle
+- Boilerplate code
+- Type definitions
+- Unit tests
+- Refactoring
+- Documentation
+- Error message parsing
+- Regex patterns
+- SQL queries
+- CSS/styling
+- API integrations
+
+### You Control
+- Architecture decisions
+- Security-critical code
+- Business logic
+- Performance optimization
+- Database schema design
+- UX decisions
+- Code review
+- Deployment/infra
+
+---
+
+## Testing Loop
+
+```
+1. AI generates code
+2. You READ it (actually read it)
+3. Run it locally
+4. Check edge cases
+5. Run tests
+6. Build passes
+7. Only then commit
+```
+
+### Test-Driven Vibecoding
+
+```
+Step 1: "Write a test for [function]"
+Step 2: "Implement to make test pass"
+Step 3: Run test → verify
+Step 4: "Add edge case tests"
+Step 5: Iterate until solid
+```
+
+---
+
+## Speed Techniques
+
+### Token Efficiency
+- Use file references instead of pasting
+- Don't repeat context AI has
+- Stop mid-generation if you have enough
+- One clear ask per message
+
+### Batch Operations
+```
+❌ "Create User model" → "Create Post model" → "Create Comment model"
+✅ "Create these models: User, Post, Comment with these relationships..."
+```
+
+### Template Reuse
+```
+"Create CommentsService following the exact pattern in PostsService"
+```
+
+---
+
+## Security Mindset
+
+### Core Principles
+- Never Trust User Input
+- Defense in Depth
+- Least Privilege
+- Fail Securely
+- Security by Design
+
+### Cost Control (Paid Services)
+- SHOW THE MATH - Calculate max monthly cost
+- LIMIT EVERYTHING - No operation without maximum
+- PREVENT LOOPS - Circuit breakers for recursion
+
+---
+
+## Common Antipatterns
+
+| Antipattern | Fix |
+|-------------|-----|
+| YOLO Prompting (huge requests) | One feature at a time |
+| Blind Trust | Read and test everything |
+| Context Neglect | Complete context sandwich |
+| Fix Forward Forever | Oneshot after 3 strikes |
+| Security Afterthought | Security from day 1 |
+| No Tests | Tests alongside code |
+| Dependency Bloat | Ask "Can this be done without a library?" |

package/dist/docs/PROMPTS.md

@@ -0,0 +1,347 @@
+# Expert Prompts Library
+
+All the expert prompts that Midas exposes.
+
+---
+
+## Session Prompts
+
+### master_prompt
+
+The prompt that sets up an entire development session:
+
+```
+# Read and understand user rules, research each for complete understanding
+
+# Ask me any clarifying questions (hallucination avoidance)
+
+# Make todos of all tasks, use high IQ strategy for safety and 
+# correctness as you create and order each, add todos for testing 
+# of all code changes and additions, research documentation and 
+# best practices online, don't start yet
+```
+
+**Why it works:**
+1. Loads rules first (foundation)
+2. Forces clarifying questions (prevents hallucination)
+3. Creates structured plan (prevents chaos)
+4. Doesn't start yet (planning before execution)
+
+---
+
+### execution_prompt
+
+After planning, kick off execution:
+
+```
+# Continue todos, do each comprehensively and in highest IQ way possible
+
+# Build test and write AND run test scripts then fix and repeat 
+# process of writing tests and running them until all tests pass
+
+# Short commit message once individual todos are complete and proceed
+```
+
+**Why it works:**
+- Separates planning from execution
+- Forces test-driven approach
+- Incremental commits (clean history)
+
+---
+
+## Refactoring Prompts
+
+### safe_refactor
+
+When moving code between files:
+
+```
+SAFE REFACTORING GUIDE:
+
+0. Comment out code on original file first
+1. Split large classes into smaller, focused class files
+2. Copy code verbatim - Don't modify logic when moving to new files
+3. Extract logical groups - Move related functions/components together
+4. Use proper exports/imports - Maintain all references between files
+5. Keep dependencies intact - Ensure imports are accessible to new files
+6. Test frequently - Verify functionality after each extraction
+```
+
+**Why Step 0 is crucial:** Commenting first means you can instantly restore if something breaks.
+
+---
+
+## Feature Development Prompts
+
+### feature_planning
+
+```
+I need to implement [FEATURE].
+
+1. First, read these files to understand current implementation:
+   - [file1]
+   - [file2]
+
+2. Research the documentation for [LIBRARY/API]
+
+3. Create a plan with:
+   - Files to create/modify
+   - Tests to write
+   - Edge cases to handle
+
+4. Don't write code yet - just the plan.
+```
+
+---
+
+### feature_implementation
+
+```
+Now implement [FEATURE] following the plan.
+
+Requirements:
+- Write the test file FIRST
+- Then implement to make tests pass
+- Each function should do ONE thing
+- No external dependencies unless absolutely necessary
+- Add error handling for: [list edge cases]
+
+After each file, run: npm run test
+```
+
+---
+
+## Bug Fixing Prompts
+
+### bug_investigation
+
+```
+There's a bug where [DESCRIBE BEHAVIOR].
+
+Expected: [WHAT SHOULD HAPPEN]
+Actual: [WHAT HAPPENS]
+
+Here's the error log:
+```
+[PASTE ERROR]
+```
+
+1. Read the relevant files
+2. Identify the root cause (not just symptoms)
+3. Explain WHY the bug occurs
+4. Don't fix yet - just diagnose
+```
+
+---
+
+### bug_fix
+
+```
+Now fix the bug.
+
+Requirements:
+- Write a test that FAILS with the current bug
+- Fix the code to make the test pass
+- Verify no other tests broke
+- Explain what you changed and why
+```
+
+---
+
+## Code Review Prompts
+
+### security_review
+
+```
+Review this code for security vulnerabilities:
+
+[PASTE CODE or @file reference]
+
+Check specifically for:
+- SQL injection
+- XSS vulnerabilities
+- Authentication bypasses
+- Authorization flaws
+- Data exposure
+- Insecure dependencies
+- Hardcoded secrets
+
+For each issue found:
+1. Describe the vulnerability
+2. Show the vulnerable code
+3. Provide the fix
+```
+
+---
+
+### performance_review
+
+```
+Review this code for performance issues:
+
+[PASTE CODE or @file reference]
+
+Check for:
+- N+1 queries
+- Unnecessary re-renders
+- Memory leaks
+- Blocking operations
+- Missing caching opportunities
+- Inefficient algorithms
+
+For each issue:
+1. Current complexity (O notation if applicable)
+2. Impact on user experience
+3. Suggested optimization
+```
+
+---
+
+## Research Prompts
+
+### technology_comparison
+
+```
+I need to choose between [OPTION A] and [OPTION B] for [USE CASE].
+
+My requirements:
+- [Requirement 1]
+- [Requirement 2]
+- [Requirement 3]
+
+Compare them on:
+1. Learning curve
+2. Performance
+3. Community/support
+4. Cost
+5. Integration with my stack: [LIST STACK]
+
+Give me a recommendation with reasoning.
+```
+
+---
+
+### best_practices_research
+
+```
+Research current best practices for [TOPIC] in 2024.
+
+I'm using: [TECH STACK]
+
+I need to know:
+1. Industry standard approach
+2. Common pitfalls to avoid
+3. Security considerations
+4. Performance implications
+5. Code examples
+
+Cite sources where possible.
+```
+
+---
+
+## Problem-Solving Prompts
+
+### oneshot_retry
+
+When first attempt fails:
+
+```
+[ORIGINAL REQUEST]
+
+Here's what happened on first attempt:
+- Error: [PASTE ERROR]
+- What I observed: [DESCRIBE BEHAVIOR]
+
+What I learned:
+- [Insight 1]
+- [Insight 2]
+
+Requirements for retry:
+- [Specific requirement based on learning]
+- [Another requirement]
+- Avoid: [What NOT to do]
+```
+
+---
+
+### tornado_trigger
+
+When stuck on a problem:
+
+```
+I need to [implement feature / fix bug].
+
+Before writing code:
+1. RESEARCH: Look up the documentation for [relevant APIs/libraries]
+2. Identify common pitfalls and best practices
+
+Then:
+3. LOGS: Add strategic console.logs at decision points
+4. TESTS: Write tests that verify the expected behavior
+
+Show me all three parts, then implement the solution.
+```
+
+---
+
+### horizon_expansion
+
+When output doesn't fit:
+
+```
+The output doesn't match what I need.
+
+HORIZONTAL CONTEXT (what AI was missing):
+
+Integrations:
+- This connects to [existing system]
+- Must use [existing pattern/service]
+
+Constraints:
+- Cannot use [limitation]
+- Must stay under [limit]
+
+Patterns:
+- Follow the pattern in [file]
+- Use [naming convention]
+
+History:
+- We use X because [reason]
+
+Please regenerate with this context.
+```
+
+---
+
+## The Prompt Formula
+
+Every effective prompt follows:
+
+```
+[CONTEXT] + [TASK] + [CONSTRAINTS] + [OUTPUT FORMAT]
+```
+
+**Example:**
+```
+CONTEXT:     "We have a Next.js 14 app with Prisma and PostgreSQL."
+TASK:        "Add rate limiting to the /api/auth endpoints."
+CONSTRAINTS: "Use Redis. Max 5 attempts per minute per IP."
+OUTPUT:      "Provide the middleware code and explain implementation."
+```
+
+---
+
+## Quick Reference Phrases
+
+| Situation | Key Phrase |
+|-----------|------------|
+| Prevent hallucination | "Ask me clarifying questions first" |
+| Force planning | "Don't write code yet - just the plan" |
+| Ensure testing | "Write the test FIRST, then implement" |
+| Safe refactoring | "Comment out before moving" |
+| Root cause analysis | "Explain WHY, don't just fix" |
+| Current practices | "Research best practices for 2024" |
+| Simplicity | "Give me the simplest possible implementation" |
+| No dependencies | "Can this be done without adding a library?" |
+| Focus | "Each function should do ONE thing" |