midas-mcp 5.44.4 → 5.44.6

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

@@ -0,0 +1,128 @@
+---
+name: tornado-debug
+description: Systematic debugging - Research + Logs + Tests cycle
+auto_trigger:
+  - "tornado"
+  - "stuck debugging"
+  - "same error again"
+  - "tried everything"
+---
+
+# Tornado Debugging
+
+You've hit the same error multiple times. Random fixes won't work. Time for systematic debugging.
+
+## The Tornado Formula
+
+```
+TORNADO = RESEARCH + LOGS + TESTS → REPEAT
+```
+
+## Step 1: RESEARCH (10 minutes)
+
+Search for the **exact** error message:
+
+```bash
+# GitHub Issues
+gh search issues "[paste exact error]"
+
+# Stack Overflow (in browser)
+site:stackoverflow.com "[paste exact error]"
+
+# Library docs
+open https://[library].dev/docs/troubleshooting
+```
+
+**Look for:**
+- ✅ Same error, solved issue → try their solution
+- ✅ Same error, open issue → workaround in comments?
+- ✅ Version-specific → check your version
+- ❌ No results → your bug is novel (rare)
+
+## Step 2: LOGS (5 minutes)
+
+Add strategic logging around the failure point:
+
+```typescript
+// Log inputs
+console.log('=== TORNADO DEBUG ===');
+console.log('function:', 'problematicFunction');
+console.log('args:', JSON.stringify(args, null, 2));
+
+// Log state
+console.log('this.state:', this.state);
+console.log('env:', process.env.NODE_ENV);
+
+// Log the failure
+try {
+  const result = problematicFunction(args);
+  console.log('result:', result);
+  console.log('typeof:', typeof result);
+} catch (e) {
+  console.log('CAUGHT:', e.message);
+  console.log('STACK:', e.stack);
+  console.log('ARGS WERE:', args);
+}
+```
+
+## Step 3: TESTS (15 minutes)
+
+Write a minimal reproduction:
+
+```typescript
+describe('bug reproduction', () => {
+  it('fails with specific input', () => {
+    // EXACT values from your logs
+    const input = { /* paste from logs */ };
+    
+    // What SHOULD happen
+    expect(buggyFunction(input)).toBe(expected);
+    
+    // If it throws, test that:
+    // expect(() => buggyFunction(input)).toThrow('specific error');
+  });
+});
+```
+
+**Run it:**
+```bash
+npm test -- --grep "bug reproduction" --watch
+```
+
+Now iterate: change code → test runs → see result.
+
+## Step 4: REPEAT
+
+After each cycle, you know more:
+- Cycle 1: You know the exact error message
+- Cycle 2: You know the input that causes it
+- Cycle 3: You know which line fails
+- Cycle 4: You understand why → you can fix it
+
+## Common Breakthroughs
+
+| After Research | Try This |
+|----------------|----------|
+| "Known issue in v2.3" | Upgrade/downgrade dependency |
+| "Requires config option X" | Add missing configuration |
+| "Bug in library" | Workaround or fork |
+
+| After Logs | Try This |
+|------------|----------|
+| Input is undefined | Trace where it should come from |
+| Type is wrong | Check where type changes |
+| Called with old value | Stale closure or async issue |
+
+| After Tests | Try This |
+|-------------|----------|
+| Test passes, production fails | Environment difference |
+| Test fails same way | Minimal fix iterations |
+
+## Exit Criteria
+
+You're done with Tornado when:
+- ✅ Test passes
+- ✅ You can explain WHY it was broken
+- ✅ You can explain WHY your fix works
+
+Now commit and move on.

package/README.md

@@ -19,12 +19,20 @@ This launches the interactive TUI coach. Press `?` for help, `p` to copy the rec
 
 ## Installation (Optional)
 
-For global installation:
+For global installation (enables `midas` command):
 
 ```bash
 npm install -g midas-mcp
 ```
 
+Or add a shell alias to `~/.zshrc` or `~/.bashrc`:
+
+```bash
+alias midas="npx midas-mcp@latest"
+```
+
+Then reload your shell: `source ~/.zshrc`
+
 ## Cursor Configuration
 
 Add to your Cursor settings (`~/.cursor/mcp.json`):
@@ -199,6 +207,48 @@ npx midas-mcp whoami
 
 Shows your authenticated GitHub username and sync configuration status.
 
+## Remote Pilot (Control from Phone)
+
+Run AI coding tasks from your phone while your laptop works in the background.
+
+### Start Remote Pilot
+
+```bash
+npx midas-mcp pilot --remote
+```
+
+This displays a QR code in your terminal. Scan it with your phone to open the mobile dashboard.
+
+### How It Works
+
+1. **Laptop**: Run `npx midas-mcp pilot --remote` - displays QR code, waits for commands
+2. **Phone**: Scan QR → opens mobile dashboard at `dashboard.midasmcp.com/pilot/...`
+3. **Execute**: Tap quick actions or type custom prompts
+4. **Claude Code runs locally** on your laptop, output streams to your phone
+
+### Quick Actions Available
+
+- **Run Tests**: Execute test suite and fix failures
+- **Fix Lints**: Run linter and auto-fix issues  
+- **Build**: Compile project and resolve errors
+- **Analyze**: Get AI analysis and next step suggestions
+- **Custom prompts**: Send any instruction to Claude Code
+
+### Requirements
+
+- [Claude Code CLI](https://claude.ai/code) installed on your laptop
+- GitHub account (for authentication)
+
+### Other Pilot Modes
+
+```bash
+# Watch mode - poll dashboard for queued commands
+npx midas-mcp pilot --watch
+
+# Single command execution
+npx midas-mcp pilot "Fix the bug in auth.ts"
+```
+
 ## Development
 
 ```bash

package/dist/.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/dist/.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/dist/.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/dist/.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/dist/.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/dist/.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"
+  }
+}