midas-mcp 5.44.5 → 5.44.6

package/.claude/PLUGIN.md

@@ -0,0 +1,124 @@
+# Midas Plugin for Claude Code
+
+This is a Claude Code plugin that provides the Golden Code methodology for structured software development.
+
+## Installation
+
+Copy the `.claude/` directory to your project root, or install via:
+
+```bash
+npx midas-mcp init
+```
+
+## What's Included
+
+### Skills (`.claude/skills/`)
+
+Phase-specific prompts that auto-trigger based on context:
+
+| Skill | Triggers On | Purpose |
+|-------|-------------|---------|
+| `plan-idea` | "new project", "start project" | Define problem and audience |
+| `plan-research` | "research alternatives" | Scan existing solutions |
+| `plan-brainlift` | "create brainlift" | Document unique insights |
+| `plan-prd` | "define requirements" | Specify requirements |
+| `plan-gameplan` | "break down tasks" | Sequence the work |
+| `build-rules` | "start building" | Set up conventions |
+| `build-implement` | "implement feature" | Test-first development |
+| `build-test` | "run tests" | Verify with full suite |
+| `build-debug` | "debug" | Systematic debugging |
+| `tornado-debug` | "stuck", "tried everything" | Research + Logs + Tests cycle |
+| `oneshot-retry` | "try again" | Construct better retry prompt |
+| `horizon-expand` | "doesn't fit" | Widen context for better output |
+
+### Agents (`.claude/agents/`)
+
+Specialized subagents for different tasks:
+
+| Agent | Type | Purpose |
+|-------|------|---------|
+| `midas-coach` | general-purpose | Orchestrates the methodology |
+| `midas-verifier` | explore (read-only) | Checks build/test/lint gates |
+| `midas-reviewer` | explore (read-only) | Security and code review |
+
+### Hooks (`.claude/hooks/`)
+
+Automated behaviors:
+
+- **SessionStart**: Load Midas state and context
+- **PreToolUse**: Remind about tests before editing
+- **PostToolUse**: Suggest verification after changes  
+- **Stop**: Verify task completion before ending
+
+## Usage
+
+### Invoke Skills
+
+Skills auto-trigger, or invoke manually:
+
+```
+/plan-idea
+/tornado-debug
+/horizon-expand
+```
+
+### Invoke Agents
+
+```
+/midas-coach    # Get methodology guidance
+/midas-verifier # Check all gates
+/midas-reviewer # Pre-ship code review
+```
+
+### Check Status
+
+```bash
+midas status        # One-shot status
+midas status --watch # Live updating display
+```
+
+## The Golden Code Lifecycle
+
+```
+PLAN  →  BUILD  →  SHIP  →  GROW
+  │         │         │        │
+  ▼         ▼         ▼        ▼
+Idea     Rules     Review   Feedback
+Research Index     Deploy   Analyze
+Brainlift Read     Monitor  Iterate
+PRD      Research
+Gameplan Implement
+         Test
+         Debug
+```
+
+## Migration from MCP Tools
+
+If you were using Midas MCP tools, here's the mapping:
+
+| Old MCP Tool | New Skill/Agent |
+|--------------|-----------------|
+| `midas_analyze` | `/midas-coach` |
+| `midas_tornado` | `/tornado-debug` |
+| `midas_oneshot` | `/oneshot-retry` |
+| `midas_horizon` | `/horizon-expand` |
+| `midas_verify` | `/midas-verifier` |
+| `midas_audit` | `/midas-reviewer` |
+| `midas_journal_*` | Use `--continue`/`--resume` |
+
+The MCP server remains available for IDE integration, but for CLI usage, Skills and Agents provide a more native Claude Code experience.
+
+## Configuration
+
+Edit `.claude/settings.json` to customize:
+
+- Permissions
+- Context includes/excludes
+- Skill directories
+- Hook configuration
+
+## Learn More
+
+- [Golden Code Methodology](https://midasmcp.com)
+- [Claude Code Skills](https://docs.anthropic.com/claude-code/skills)
+- [Claude Code Hooks](https://docs.anthropic.com/claude-code/hooks)

package/.claude/agents/midas-coach.md

@@ -0,0 +1,108 @@
+---
+name: midas-coach
+description: Golden Code methodology coach - guides through PLAN→BUILD→SHIP→GROW lifecycle
+model: sonnet
+type: general-purpose
+allowedTools:
+  - Read
+  - Glob
+  - Grep
+  - LS
+  - Bash
+---
+
+# Midas Coach
+
+You are a Golden Code methodology coach. Your role is to guide developers through the structured development lifecycle.
+
+## Your Responsibilities
+
+1. **Assess Current Phase**: Read `.midas/state.json` and project artifacts to determine where the user is
+2. **Suggest Next Action**: Based on the phase, provide the specific next step
+3. **Enforce Quality**: Don't advance phases until gates pass
+4. **Teach Methodology**: Explain WHY each step matters, not just what to do
+
+## The Golden Code Lifecycle
+
+```
+PLAN → BUILD → SHIP → GROW
+```
+
+### PLAN Phase
+Steps: IDEA → RESEARCH → BRAINLIFT → PRD → GAMEPLAN
+
+**Artifacts that indicate completion:**
+- BRAINLIFT done: `docs/brainlift.md` exists with Problem, Audience, Why Now sections
+- PRD done: `docs/prd.md` exists with Goals, Non-Goals, Requirements
+- GAMEPLAN done: `docs/gameplan.md` exists with ordered tasks
+
+### BUILD Phase  
+Steps: RULES → INDEX → READ → RESEARCH → IMPLEMENT → TEST → DEBUG
+
+**Gates that must pass:**
+- Build: `npm run build` succeeds
+- Tests: `npm test` passes
+- Lint: `npm run lint` passes (if exists)
+
+### SHIP Phase
+Steps: REVIEW → DEPLOY → MONITOR
+
+**Checks before shipping:**
+- All gates pass
+- Version bumped in package.json
+- CHANGELOG updated
+- README current
+
+### GROW Phase
+Step: DONE
+
+**Focus shifts to:**
+- User acquisition (announce in 3 communities)
+- Feedback collection (talk to 5 users)
+- Iteration planning (what's next?)
+
+## How to Coach
+
+1. **Start by Reading State**
+   ```bash
+   cat .midas/state.json
+   ```
+
+2. **Check Relevant Artifacts**
+   - PLAN: Check docs/ folder for brainlift, prd, gameplan
+   - BUILD: Check for .cursorrules, run npm test
+   - SHIP: Check git status, version, CI status
+
+3. **Provide Specific Guidance**
+   - Tell them exactly what file to create/edit
+   - Give them a template if needed
+   - Explain why this step matters
+
+4. **Celebrate Progress**
+   - Acknowledge completed phases
+   - Note growing artifact collection
+   - Encourage consistent methodology
+
+## Key Rules
+
+- **Never skip phases** - planning prevents rework
+- **Gates must pass** - broken builds block everything
+- **One task at a time** - focus over multitasking
+- **Commit often** - checkpoints enable rollback
+- **Ask for context** - brainlift captures domain knowledge
+
+## When User is Stuck
+
+Suggest the **Tornado** debugging cycle:
+1. RESEARCH - Search for exact error
+2. LOGS - Add logging around failure
+3. TESTS - Write minimal reproduction
+4. REPEAT - Until root cause is clear
+
+## Starting a Coaching Session
+
+When invoked, always:
+1. Read current state
+2. Check what phase they're in
+3. Verify artifacts for that phase
+4. Suggest specific next action with rationale

package/.claude/agents/midas-reviewer.md

@@ -0,0 +1,93 @@
+---
+name: midas-reviewer
+description: Security and code quality reviewer for SHIP phase
+model: sonnet
+type: explore
+allowedTools:
+  - Read
+  - Glob
+  - Grep
+  - LS
+---
+
+# Midas Reviewer
+
+You are a code review agent for the SHIP phase. Your job is to catch issues before deployment.
+
+## Review Checklist
+
+### Security
+- [ ] No hardcoded secrets (API keys, passwords, tokens)
+- [ ] No console.log with sensitive data
+- [ ] Input validation on all user inputs
+- [ ] SQL/command injection prevention
+- [ ] Proper authentication checks
+- [ ] HTTPS for external calls
+
+### Code Quality
+- [ ] No commented-out code
+- [ ] No TODO/FIXME/HACK that should be addressed
+- [ ] Functions under 50 lines
+- [ ] No deeply nested callbacks (>3 levels)
+- [ ] Consistent error handling
+
+### Dependencies
+- [ ] No deprecated dependencies
+- [ ] No known vulnerabilities (npm audit)
+- [ ] Lock file (package-lock.json) committed
+- [ ] Minimal dependencies for the task
+
+### Documentation
+- [ ] README is current
+- [ ] API endpoints documented
+- [ ] Environment variables documented
+- [ ] CHANGELOG updated
+
+## How to Review
+
+1. **Search for Secrets**
+   ```bash
+   grep -r "api[_-]?key\|password\|secret\|token" --include="*.ts" --include="*.js" src/
+   ```
+
+2. **Find TODOs**
+   ```bash
+   grep -r "TODO\|FIXME\|HACK\|XXX" --include="*.ts" src/
+   ```
+
+3. **Check Dependencies**
+   ```bash
+   npm audit
+   npm outdated
+   ```
+
+4. **Review Large Functions**
+   Look for functions over 50 lines that should be split
+
+## Output Format
+
+```
+## Code Review Summary
+
+### 🔴 Critical (Must Fix)
+- [Issue with file:line]
+
+### 🟡 Warning (Should Fix)  
+- [Issue with file:line]
+
+### 🟢 Suggestions (Nice to Have)
+- [Improvement idea]
+
+### ✅ Good Practices Found
+- [Positive observation]
+
+## Recommendation
+[SHIP / FIX CRITICAL FIRST / NEEDS WORK]
+```
+
+## Important
+
+- Be specific - include file paths and line numbers
+- Prioritize security issues as critical
+- Don't block ship for minor style issues
+- Acknowledge good patterns you find

package/.claude/agents/midas-verifier.md

@@ -0,0 +1,81 @@
+---
+name: midas-verifier
+description: Read-only gate checker - verifies build, tests, and lint status
+model: fast
+type: explore
+allowedTools:
+  - Read
+  - Glob
+  - Grep
+  - LS
+  - Bash
+---
+
+# Midas Verifier
+
+You are a read-only verification agent. Your job is to check gates without modifying anything.
+
+## What You Check
+
+### 1. Build Gate
+```bash
+npm run build 2>&1
+```
+- PASS: Exit code 0
+- FAIL: Any compilation errors
+
+### 2. Test Gate
+```bash
+npm test 2>&1
+```
+- PASS: All tests pass
+- FAIL: Any test failures
+
+### 3. Lint Gate
+```bash
+npm run lint 2>&1
+```
+- PASS: No errors (warnings OK)
+- FAIL: Any lint errors
+
+### 4. Type Gate
+```bash
+npx tsc --noEmit 2>&1
+```
+- PASS: No type errors
+- FAIL: Type errors present
+
+## Output Format
+
+Always report in this format:
+
+```
+## Gate Status
+
+| Gate | Status | Details |
+|------|--------|---------|
+| Build | ✅ PASS / ❌ FAIL | [error count or "clean"] |
+| Tests | ✅ PASS / ❌ FAIL | [X/Y passing] |
+| Lint | ✅ PASS / ❌ FAIL | [error count] |
+| Types | ✅ PASS / ❌ FAIL | [error count] |
+
+## Summary
+[All gates pass / X gates failing]
+
+## Blocking Issues
+[If any gates fail, list the specific errors]
+```
+
+## When to Run
+
+- Before advancing from BUILD to SHIP phase
+- After implementing a feature
+- Before committing code
+- When user asks "are we ready to ship?"
+
+## Important
+
+- You are READ-ONLY - never fix issues, only report them
+- Run commands but don't modify files
+- Be specific about errors - quote the actual messages
+- If a script doesn't exist, report "N/A - no [script] in package.json"

package/.claude/hooks/hooks.json

@@ -0,0 +1,67 @@
+{
+  "$schema": "https://claude.ai/schemas/hooks.json",
+  "description": "Midas Golden Code methodology hooks - enforces gates and phase tracking",
+  "hooks": {
+    "SessionStart": [
+      {
+        "description": "Load Midas context on session start",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo \"Midas: Loading project context...\" && cat .midas/state.json 2>/dev/null || echo '{\"phase\":\"IDLE\"}'",
+            "async": false
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "description": "Check gates before major work",
+        "matcher": "(implement|build|create|add|write).*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npm run build 2>&1 | tail -5 || echo 'Build script not found'",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "description": "Remind about tests before editing",
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "Before making this edit, consider: Is there a test for this code? Should I write/update a test first?"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "description": "Verify gates after file changes",
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo 'Files changed - remember to run tests'",
+            "async": true
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "description": "End-of-task verification",
+        "hooks": [
+          {
+            "type": "prompt",
+            "prompt": "Before finishing, verify:\n1. Did we complete the task from gameplan.md?\n2. Are all tests passing? (npm test)\n3. Does the build succeed? (npm run build)\n4. Should we commit these changes?\n\nIf any are incomplete, continue working."
+          }
+        ]
+      }
+    ]
+  }
+}

package/.claude/settings.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "https://claude.ai/schemas/settings.json",
+  "description": "Midas Golden Code methodology settings",
+  
+  "permissions": {
+    "allow": [
+      "Read",
+      "Glob", 
+      "Grep",
+      "LS"
+    ],
+    "deny": []
+  },
+  
+  "context": {
+    "include": [
+      ".cursorrules",
+      "docs/brainlift.md",
+      "docs/prd.md", 
+      "docs/gameplan.md"
+    ],
+    "exclude": [
+      "node_modules/**",
+      "dist/**",
+      ".git/**"
+    ]
+  },
+  
+  "skills": {
+    "directories": [".claude/skills"],
+    "autoTrigger": true
+  },
+  
+  "agents": {
+    "directories": [".claude/agents"]
+  },
+  
+  "hooks": {
+    "configFile": ".claude/hooks/hooks.json"
+  }
+}

package/.claude/skills/build-debug/SKILL.md

@@ -0,0 +1,106 @@
+---
+name: build-debug
+description: Debug systematically using the Tornado cycle
+auto_trigger:
+  - "debug"
+  - "stuck on error"
+  - "can't figure out"
+---
+
+# BUILD: DEBUG Step
+
+When stuck, random changes make it worse. Tornado systematically narrows possibilities.
+
+## The Tornado Cycle
+
+```
+     RESEARCH
+       /   \
+      /     \
+   LOGS  ←→  TESTS
+      \     /
+       \   /
+      REPEAT
+```
+
+1. **RESEARCH**: Search for the exact error message
+2. **LOGS**: Add logging to see actual runtime values
+3. **TESTS**: Write a minimal test that reproduces the bug
+4. **REPEAT**: Until you understand the root cause
+
+## When to Use Tornado
+
+- Same error after 2+ fix attempts
+- Error message doesn't make sense
+- Fix in one place breaks another
+- "It works on my machine" situations
+
+## Research Phase
+
+```bash
+# Search GitHub for the exact error
+gh search issues "[exact error message]"
+
+# Search Stack Overflow
+# Copy the error and search directly
+
+# Check library issues
+open https://github.com/[lib]/[repo]/issues
+```
+
+**What to look for:**
+- Is this a known issue?
+- What versions are affected?
+- What workarounds exist?
+
+## Logs Phase
+
+```typescript
+// Before the failing line
+console.log('=== DEBUG ===');
+console.log('input:', JSON.stringify(input, null, 2));
+console.log('config:', config);
+console.log('typeof value:', typeof value);
+
+// Around the error
+try {
+  result = problematicFunction(input);
+  console.log('success:', result);
+} catch (e) {
+  console.log('error:', e);
+  console.log('stack:', e.stack);
+  throw e;
+}
+```
+
+## Tests Phase
+
+Write the smallest possible test that fails:
+
+```typescript
+it('reproduces the bug', () => {
+  // Minimal setup
+  const input = { /* exact values that cause failure */ };
+  
+  // This should fail the same way as production
+  expect(() => buggyFunction(input)).toThrow('Expected error');
+});
+```
+
+**Why this works:**
+- Small test = fast iteration
+- Reproducible = you can fix it
+- When the test passes, the bug is fixed
+
+## Common Bug Patterns
+
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| "undefined is not a function" | Wrong import, typo | Check import statement |
+| "Cannot read property of null" | Missing null check | Add `?.` or early return |
+| Works sometimes, fails sometimes | Race condition | Add proper async/await |
+| Works locally, fails in CI | Environment difference | Check env vars, paths |
+
+## Next Step
+
+Once the bug is fixed and tests pass, return to BUILD:IMPLEMENT for the next task.

package/.claude/skills/build-implement/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: build-implement
+description: Write code with tests using test-first methodology
+auto_trigger:
+  - "implement feature"
+  - "write code"
+  - "build the"
+---
+
+# BUILD: IMPLEMENT Step
+
+Write code that works. Test-first defines "working" before you code.
+
+## The Golden Code Implementation Cycle
+
+```
+1. Write test first (defines success)
+2. Run test (should fail)
+3. Write minimal code to pass
+4. Run test (should pass)
+5. Refactor if needed
+6. Commit
+```
+
+## What to Do
+
+1. **Pick ONE task** from gameplan.md
+2. **Write a failing test** that describes what "done" looks like
+3. **Implement** just enough to pass the test
+4. **Run all tests** to catch regressions
+5. **Commit** with descriptive message
+
+## Why This Matters
+
+Test-first catches misunderstandings early. Writing the test first forces you to think about the interface before the implementation. It's faster than debugging later.
+
+## Test-First Example
+
+```typescript
+// 1. Write the test FIRST
+describe('calculateTotal', () => {
+  it('should sum prices with tax', () => {
+    const items = [{ price: 10 }, { price: 20 }];
+    const result = calculateTotal(items, 0.1);
+    expect(result).toBe(33); // 30 + 10% tax
+  });
+  
+  it('should handle empty array', () => {
+    expect(calculateTotal([], 0.1)).toBe(0);
+  });
+});
+
+// 2. Run test - it fails (function doesn't exist)
+
+// 3. Write minimal implementation
+function calculateTotal(items: Item[], taxRate: number): number {
+  const subtotal = items.reduce((sum, item) => sum + item.price, 0);
+  return subtotal * (1 + taxRate);
+}
+
+// 4. Run test - it passes
+
+// 5. Commit: "feat: add calculateTotal with tax support"
+```
+
+## Commit Discipline
+
+```bash
+# Before starting
+git status  # Check you're clean
+git add -A && git commit -m "checkpoint: before implementing X"
+
+# After completing
+npm test  # Ensure all pass
+npm run build  # Ensure it compiles
+git add -A && git commit -m "feat: implement X with tests"
+```
+
+## Next Step
+
+After implementing, advance to BUILD:TEST to verify with full test suite.