agentic-loop 3.5.1 → 3.6.0

package/README.md

@@ -4,7 +4,25 @@
 
 You describe what you want to build. Claude Code writes a PRD (Product Requirements Document) with small, testable stories. Ralph executes each story automatically - coding, testing, and committing in a loop until everything passes.
 
-> **Optimized for:** Python, TypeScript, React, Go/Hugo, and Docker projects.
+> **Optimized for:** Python, TypeScript, React, Go/Hugo, FastMCP, and Docker projects.
+
+---
+
+## Supported Project Types
+
+Ralph auto-detects your project type and configures itself accordingly:
+
+| Type | Detection | Auto-Configured |
+|------|-----------|-----------------|
+| **FastMCP** | `fastmcp` in pyproject.toml | Server module, MCP port, transport, subprojects |
+| **FastAPI** | `fastapi` in pyproject.toml | uvicorn dev server, pytest, ruff |
+| **Django** | `django` in pyproject.toml or manage.py | migrations, pytest, ruff |
+| **Python** | pyproject.toml or requirements.txt | pytest, ruff, uv/poetry detection |
+| **Node.js** | package.json | npm/yarn/pnpm, vitest/jest, eslint |
+| **React** | `react` in package.json | Vite/Next.js, TypeScript, Tailwind |
+| **Go/Hugo** | go.mod or hugo.toml | Hugo server, Go build |
+| **Rust** | Cargo.toml | cargo build/test/clippy |
+| **Fullstack** | frontend + backend directories | Monorepo support, separate configs |
 
 ---
 

package/bin/ralph.sh

@@ -37,10 +37,44 @@ export RALPH_DIR PROMPT_FILE RALPH_LIB RALPH_TEMPLATES
 if [[ ! -d ".ralph" ]]; then
   mkdir -p ".ralph/archive" ".ralph/screenshots"
 fi
-# Always ensure config.json exists and run auto-detection if newly created
+# Check if config.json needs to be created (but don't create it yet - let init copy the template)
 if [[ ! -f ".ralph/config.json" ]]; then
-  echo '{}' > ".ralph/config.json"
-  # Run auto-detection (function is in init.sh, sourced below)
+  # Copy config template based on detected project type
+  _project_type="minimal"
+  if [[ -f "pyproject.toml" ]]; then
+    if grep -qE "(fastmcp|\"fastmcp\"|'fastmcp')" pyproject.toml 2>/dev/null; then
+      _project_type="fastmcp"
+    elif grep -qE "(fastapi|\"fastapi\"|'fastapi')" pyproject.toml 2>/dev/null; then
+      _project_type="fastapi"
+    elif grep -qE "(django|\"django\"|'django')" pyproject.toml 2>/dev/null || [[ -f "manage.py" ]]; then
+      _project_type="django"
+    else
+      _project_type="python"
+    fi
+  elif [[ -f "go.mod" ]]; then
+    _project_type="go"
+  elif [[ -f "Cargo.toml" ]]; then
+    _project_type="rust"
+  elif [[ -d "frontend" ]] && [[ -d "backend" || -d "core" || -d "apps" ]]; then
+    _project_type="fullstack"
+  elif [[ -f "package.json" ]]; then
+    _project_type="node"
+  fi
+
+  _config_template="$RALPH_TEMPLATES/config/${_project_type}.json"
+  if [[ -f "$_config_template" ]]; then
+    cp "$_config_template" ".ralph/config.json"
+  else
+    # Fall back to minimal config if template doesn't exist
+    _config_template="$RALPH_TEMPLATES/config/minimal.json"
+    if [[ -f "$_config_template" ]]; then
+      cp "$_config_template" ".ralph/config.json"
+    else
+      echo '{"projectType": "unknown"}' > ".ralph/config.json"
+    fi
+  fi
+  unset _project_type _config_template
+  # Run auto-detection to fill in project-specific values
   _ralph_needs_autoconfig=true
 fi
 [[ ! -f ".ralph/signs.json" ]] && echo '{"signs": []}' > ".ralph/signs.json"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-loop",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "description": "Autonomous AI coding loop - PRD-driven development with Claude Code",
   "author": "Allie Jones <allie@allthrive.ai>",
   "license": "MIT",

package/ralph/init.sh

@@ -145,8 +145,35 @@ detect_project_type() {
     project_type="rust"
   elif [[ -f "go.mod" ]]; then
     project_type="go"
-  elif [[ -f "pyproject.toml" || -f "requirements.txt" || -f "setup.py" ]]; then
-    project_type="python"
+  # Check for Python framework variants (more specific first)
+  elif [[ -f "pyproject.toml" ]]; then
+    # FastMCP detection (check for fastmcp in any quote style)
+    if grep -qiE "(fastmcp|\"fastmcp\"|'fastmcp')" pyproject.toml 2>/dev/null; then
+      project_type="fastmcp"
+    # Django detection
+    elif grep -qiE "(django|\"django\"|'django')" pyproject.toml 2>/dev/null || [[ -f "manage.py" ]]; then
+      project_type="django"
+    # FastAPI detection
+    elif grep -qiE "(fastapi|\"fastapi\"|'fastapi')" pyproject.toml 2>/dev/null; then
+      project_type="fastapi"
+    else
+      project_type="python"
+    fi
+  elif [[ -f "requirements.txt" || -f "setup.py" ]]; then
+    # Check requirements.txt for frameworks
+    if [[ -f "requirements.txt" ]]; then
+      if grep -qi 'fastmcp' requirements.txt 2>/dev/null; then
+        project_type="fastmcp"
+      elif grep -qi 'django' requirements.txt 2>/dev/null || [[ -f "manage.py" ]]; then
+        project_type="django"
+      elif grep -qi 'fastapi' requirements.txt 2>/dev/null; then
+        project_type="fastapi"
+      else
+        project_type="python"
+      fi
+    else
+      project_type="python"
+    fi
   elif [[ -f "package.json" ]]; then
     project_type="node"
   fi
@@ -372,6 +399,101 @@ auto_configure_project() {
     fi
   fi
 
+  # 6. FastMCP-specific detection
+  if [[ -f "pyproject.toml" ]] && grep -qiE "(fastmcp|\"fastmcp\"|'fastmcp')" pyproject.toml 2>/dev/null; then
+    # Detect MCP server module from entry points
+    local mcp_module=""
+    # Look for [project.scripts] section with pattern: name = "module.server:main"
+    mcp_module=$(grep -A 20 '^\[project\.scripts\]' pyproject.toml 2>/dev/null | \
+                 grep -E '^\w+\s*=\s*"[^"]+\.server:' | head -1 | \
+                 sed -E 's/.*"([^"]+)\.server:.*/\1/' || true)
+
+    # Fallback: detect from src directory structure
+    if [[ -z "$mcp_module" && -d "src" ]]; then
+      for dir in src/*/; do
+        if [[ -f "${dir}server.py" ]]; then
+          mcp_module=$(basename "${dir%/}")
+          break
+        fi
+      done
+    fi
+
+    if [[ -n "$mcp_module" ]]; then
+      if ! jq -e '.mcp.serverModule' "$tmpfile" >/dev/null 2>&1 || [[ "$(jq -r '.mcp.serverModule' "$tmpfile")" == "" ]]; then
+        jq --arg mod "$mcp_module" '.mcp.serverModule = $mod' "$tmpfile" > "${tmpfile}.new" && mv "${tmpfile}.new" "$tmpfile"
+        # Also update the dev command
+        jq --arg cmd "python -m ${mcp_module}.server" '.commands.dev = $cmd' "$tmpfile" > "${tmpfile}.new" && mv "${tmpfile}.new" "$tmpfile"
+        echo "  Auto-detected mcp.serverModule: $mcp_module"
+        updated=true
+      fi
+    fi
+
+    # Detect MCP port from .env or docker-compose
+    local mcp_port=""
+    if [[ -f ".env" ]]; then
+      mcp_port=$(grep -E '^[A-Z_]*PORT=' .env 2>/dev/null | grep -v '#' | head -1 | grep -oE '[0-9]+' || true)
+    fi
+    if [[ -z "$mcp_port" ]]; then
+      for compose_file in "docker-compose.yml" "docker-compose.yaml"; do
+        if [[ -f "$compose_file" ]]; then
+          # Look for port in main app service
+          mcp_port=$(grep -A 20 -E '^\s*(app|gopa|mcp|server):' "$compose_file" 2>/dev/null | \
+                     grep -E '^\s*-\s*"?[0-9]+:[0-9]+"?' | head -1 | \
+                     grep -oE '[0-9]+:' | head -1 | tr -d ':' || true)
+          [[ -n "$mcp_port" ]] && break
+        fi
+      done
+    fi
+
+    if [[ -n "$mcp_port" ]]; then
+      if ! jq -e '.api.baseUrl' "$tmpfile" >/dev/null 2>&1 || [[ "$(jq -r '.api.baseUrl' "$tmpfile")" == "http://localhost:8000" ]]; then
+        jq --arg url "http://localhost:$mcp_port" '.api.baseUrl = $url | .urls.app = $url' "$tmpfile" > "${tmpfile}.new" && mv "${tmpfile}.new" "$tmpfile"
+        echo "  Auto-detected MCP port: $mcp_port"
+        updated=true
+      fi
+    fi
+
+    # Detect MCP transport from .env
+    if [[ -f ".env" ]]; then
+      local transport=""
+      transport=$(grep -E '^[A-Z_]*TRANSPORT=' .env 2>/dev/null | grep -v '#' | head -1 | cut -d'=' -f2 | tr -d '"'"'" || true)
+      if [[ -n "$transport" ]]; then
+        jq --arg t "$transport" '.mcp.transport = $t' "$tmpfile" > "${tmpfile}.new" && mv "${tmpfile}.new" "$tmpfile"
+      fi
+    fi
+
+    # Detect subprojects (directories with their own package.json)
+    for subdir in */; do
+      local subdir_name="${subdir%/}"
+      if [[ -f "${subdir}package.json" && "$subdir_name" != "node_modules" ]]; then
+        # Check if subproject already configured
+        if ! jq -e ".subprojects[\"$subdir_name\"]" "$tmpfile" >/dev/null 2>&1; then
+          local sub_lint="" sub_build="" sub_dev=""
+          # Detect scripts from package.json
+          if grep -q '"lint"' "${subdir}package.json" 2>/dev/null; then
+            sub_lint="npm run lint"
+          fi
+          if grep -q '"build"' "${subdir}package.json" 2>/dev/null; then
+            sub_build="npm run build"
+          fi
+          if grep -q '"dev"' "${subdir}package.json" 2>/dev/null; then
+            sub_dev="npm run dev"
+          fi
+
+          jq --arg name "$subdir_name" \
+             --arg path "$subdir_name" \
+             --arg lint "$sub_lint" \
+             --arg build "$sub_build" \
+             --arg dev "$sub_dev" \
+             '.subprojects[$name] = {path: $path, commands: {lint: $lint, build: $build, dev: $dev}}' \
+             "$tmpfile" > "${tmpfile}.new" && mv "${tmpfile}.new" "$tmpfile"
+          echo "  Auto-detected subproject: $subdir_name"
+          updated=true
+        fi
+      fi
+    done
+  fi
+
   # Save if updated
   if [[ "$updated" == "true" ]]; then
     mv "$tmpfile" "$config"

package/ralph/setup.sh

@@ -129,35 +129,74 @@ setup_ralph_dir() {
   # Copy config template based on detected project type
   if [[ ! -f ".ralph/config.json" ]]; then
     local config_template=""
+    local detected_type=""
     # Check for Go projects
     if [[ -f "go.mod" ]]; then
       config_template="$pkg_root/templates/config/go.json"
+      detected_type="go"
     # Check for Rust projects
     elif [[ -f "Cargo.toml" ]]; then
       config_template="$pkg_root/templates/config/rust.json"
+      detected_type="rust"
     # Check for Hugo projects
     elif [[ -f "hugo.toml" || -f "hugo.yaml" || -f "config.toml" ]] && [[ -d "content" || -d "layouts" || -d "themes" ]]; then
       config_template="$pkg_root/templates/config/go.json"
-    # Check for Python projects
-    elif [[ -f "manage.py" ]] || [[ -f "pyproject.toml" ]]; then
+      detected_type="hugo"
+    # Check for Python framework variants (more specific first)
+    elif [[ -f "pyproject.toml" ]]; then
+      if grep -qiE "(fastmcp|\"fastmcp\"|'fastmcp')" pyproject.toml 2>/dev/null; then
+        config_template="$pkg_root/templates/config/fastmcp.json"
+        detected_type="fastmcp"
+      elif grep -qiE "(fastapi|\"fastapi\"|'fastapi')" pyproject.toml 2>/dev/null; then
+        config_template="$pkg_root/templates/config/python.json"
+        detected_type="fastapi"
+      elif grep -qiE "(django|\"django\"|'django')" pyproject.toml 2>/dev/null || [[ -f "manage.py" ]]; then
+        config_template="$pkg_root/templates/config/python.json"
+        detected_type="django"
+      else
+        config_template="$pkg_root/templates/config/python.json"
+        detected_type="python"
+      fi
+    elif [[ -f "requirements.txt" ]]; then
+      if grep -qi 'fastmcp' requirements.txt 2>/dev/null; then
+        config_template="$pkg_root/templates/config/fastmcp.json"
+        detected_type="fastmcp"
+      elif grep -qi 'fastapi' requirements.txt 2>/dev/null; then
+        config_template="$pkg_root/templates/config/python.json"
+        detected_type="fastapi"
+      elif grep -qi 'django' requirements.txt 2>/dev/null || [[ -f "manage.py" ]]; then
+        config_template="$pkg_root/templates/config/python.json"
+        detected_type="django"
+      else
+        config_template="$pkg_root/templates/config/python.json"
+        detected_type="python"
+      fi
+    elif [[ -f "manage.py" ]]; then
       config_template="$pkg_root/templates/config/python.json"
+      detected_type="django"
     # Check for fullstack projects
     elif [[ -d "frontend" ]] && [[ -d "backend" || -d "core" || -d "apps" ]]; then
       config_template="$pkg_root/templates/config/fullstack.json"
+      detected_type="fullstack"
     # Check for Node projects
     elif [[ -f "package.json" ]]; then
       config_template="$pkg_root/templates/config/node.json"
+      detected_type="node"
     fi
 
     if [[ -n "$config_template" ]] && [[ -f "$config_template" ]]; then
       cp "$config_template" ".ralph/config.json"
+      echo "  Created .ralph/config.json (detected: $detected_type)"
     else
       echo '{"checks": {"build": true, "lint": true, "test": true}}' > ".ralph/config.json"
+      echo "  Created .ralph/config.json"
     fi
-    echo "  Created .ralph/config.json"
+
+    # Store detected type for CLAUDE.md generation
+    export RALPH_DETECTED_TYPE="$detected_type"
   fi
 
-  # Copy signs template
+  # Copy or merge signs template
   if [[ ! -f ".ralph/signs.json" ]]; then
     if [[ -f "$pkg_root/templates/signs.json" ]]; then
       cp "$pkg_root/templates/signs.json" ".ralph/signs.json"
@@ -165,6 +204,30 @@ setup_ralph_dir() {
       echo '{"signs": []}' > ".ralph/signs.json"
     fi
     echo "  Created .ralph/signs.json"
+  else
+    # Merge new default signs into existing file
+    if [[ -f "$pkg_root/templates/signs.json" ]] && command -v jq &>/dev/null; then
+      local existing_ids new_signs_added=0
+      existing_ids=$(jq -r '.signs[].id // empty' ".ralph/signs.json" 2>/dev/null | tr '\n' '|')
+
+      # Add signs from template that don't exist locally
+      while IFS= read -r sign; do
+        local sign_id
+        sign_id=$(echo "$sign" | jq -r '.id // empty')
+        if [[ -n "$sign_id" && ! "$existing_ids" =~ "$sign_id" ]]; then
+          # Add this sign to local file
+          local tmp_file
+          tmp_file=$(mktemp)
+          jq --argjson new_sign "$sign" '.signs += [$new_sign]' ".ralph/signs.json" > "$tmp_file"
+          mv "$tmp_file" ".ralph/signs.json"
+          ((new_signs_added++))
+        fi
+      done < <(jq -c '.signs[]' "$pkg_root/templates/signs.json" 2>/dev/null)
+
+      if [[ $new_signs_added -gt 0 ]]; then
+        echo "  Merged $new_signs_added new sign(s) into .ralph/signs.json"
+      fi
+    fi
   fi
 
   # Create or update PROMPT.md
@@ -323,6 +386,8 @@ setup_slash_commands() {
 # Generate CLAUDE.md with detected project info
 setup_claude_md() {
   local marker="<!-- agentic-loop-detected -->"
+  local pkg_root
+  pkg_root="$(cd "$RALPH_LIB/.." && pwd)"
 
   # Skip if we already added our section
   [[ -f "CLAUDE.md" ]] && grep -q "$marker" "CLAUDE.md" 2>/dev/null && return 0
@@ -330,6 +395,7 @@ setup_claude_md() {
   echo "Generating CLAUDE.md..."
 
   local runtime="" framework="" language="" styling="" testing="" structure=""
+  local framework_type=""  # For template selection
 
   # Detect runtime/language
   local fe_dir=""
@@ -344,18 +410,45 @@ setup_claude_md() {
   [[ -f "pyproject.toml" || -f "requirements.txt" || -f "manage.py" ]] && runtime="${runtime:+$runtime + }Python"
   [[ -f "Gemfile" ]] && runtime="Ruby"
 
-  # Detect framework
+  # Detect framework (with template type detection)
   local pkg="package.json"
   [[ -n "$fe_dir" && -f "${fe_dir}/package.json" ]] && pkg="${fe_dir}/package.json"
 
   if [[ -f "$pkg" ]]; then
     grep -q '"next"' "$pkg" 2>/dev/null && framework="Next.js"
-    grep -q '"react"' "$pkg" 2>/dev/null && [[ -z "$framework" ]] && framework="React"
+    grep -q '"react"' "$pkg" 2>/dev/null && [[ -z "$framework" ]] && framework="React" && framework_type="react"
     grep -q '"vue"' "$pkg" 2>/dev/null && framework="Vue"
     grep -q '"svelte"' "$pkg" 2>/dev/null && framework="Svelte"
     grep -q '"express"' "$pkg" 2>/dev/null && framework="${framework:+$framework + }Express"
   fi
-  [[ -f "manage.py" ]] && framework="${framework:+$framework + }Django"
+
+  # Detect Python frameworks (more specific detection)
+  if [[ -f "pyproject.toml" ]]; then
+    if grep -qiE "(fastmcp|\"fastmcp\"|'fastmcp')" pyproject.toml 2>/dev/null; then
+      framework="${framework:+$framework + }FastMCP"
+      framework_type="fastmcp"
+    elif grep -qiE "(fastapi|\"fastapi\"|'fastapi')" pyproject.toml 2>/dev/null; then
+      framework="${framework:+$framework + }FastAPI"
+      framework_type="fastapi"
+    elif grep -qiE "(django|\"django\"|'django')" pyproject.toml 2>/dev/null || [[ -f "manage.py" ]]; then
+      framework="${framework:+$framework + }Django"
+      framework_type="django"
+    fi
+  elif [[ -f "requirements.txt" ]]; then
+    if grep -qi 'fastmcp' requirements.txt 2>/dev/null; then
+      framework="${framework:+$framework + }FastMCP"
+      framework_type="fastmcp"
+    elif grep -qi 'fastapi' requirements.txt 2>/dev/null; then
+      framework="${framework:+$framework + }FastAPI"
+      framework_type="fastapi"
+    elif grep -qi 'django' requirements.txt 2>/dev/null || [[ -f "manage.py" ]]; then
+      framework="${framework:+$framework + }Django"
+      framework_type="django"
+    fi
+  elif [[ -f "manage.py" ]]; then
+    framework="${framework:+$framework + }Django"
+    framework_type="django"
+  fi
 
   # Detect Hugo (Go static site generator)
   for hugo_config in "hugo.toml" "hugo.yaml" "hugo.json" "config.toml"; do
@@ -376,6 +469,7 @@ setup_claude_md() {
   [[ -f "vitest.config.ts" || -f "vitest.config.js" ]] && testing="Vitest"
   [[ -f "jest.config.js" || -f "jest.config.ts" ]] && testing="Jest"
   [[ -f "playwright.config.ts" || -f "playwright.config.js" ]] && testing="${testing:+$testing + }Playwright"
+  [[ -f "pytest.ini" || -f "pyproject.toml" ]] && grep -q 'pytest' pyproject.toml 2>/dev/null && testing="${testing:+$testing + }pytest"
 
   # Detect Python package manager
   local python_runner=""
@@ -404,17 +498,46 @@ ${python_runner:+- Python: Use \`$python_runner\` (not bare \`python\`)}
 
 *Auto-detected by agentic-loop. Edit freely.*"
 
+  # Check for framework-specific template
+  local framework_template=""
+  if [[ -n "$framework_type" ]]; then
+    framework_template="$pkg_root/templates/examples/CLAUDE-${framework_type}.md"
+  fi
+
   if [[ -f "CLAUDE.md" ]]; then
+    # Append framework template if it exists and not already included
+    if [[ -n "$framework_template" && -f "$framework_template" ]]; then
+      local template_marker="<!-- CLAUDE-${framework_type} -->"
+      if ! grep -q "$template_marker" "CLAUDE.md" 2>/dev/null; then
+        echo "" >> CLAUDE.md
+        echo "$template_marker" >> CLAUDE.md
+        # Skip the first line (# CLAUDE.md - ...) of the template
+        tail -n +2 "$framework_template" >> CLAUDE.md
+        echo "  Appended ${framework_type} conventions to CLAUDE.md"
+      fi
+    fi
     echo "$detected_section" >> CLAUDE.md
     echo "  Updated CLAUDE.md"
   else
+    # Create new CLAUDE.md
     cat > CLAUDE.md << EOF
 # Project Guide for Claude
 
 ## Your Rules
 <!-- Add your project-specific rules, patterns, and conventions here -->
-$detected_section
 EOF
+
+    # Include framework template if available
+    if [[ -n "$framework_template" && -f "$framework_template" ]]; then
+      local template_marker="<!-- CLAUDE-${framework_type} -->"
+      echo "" >> CLAUDE.md
+      echo "$template_marker" >> CLAUDE.md
+      # Skip the first line (# CLAUDE.md - ...) of the template
+      tail -n +2 "$framework_template" >> CLAUDE.md
+      echo "  Included ${framework_type} conventions"
+    fi
+
+    echo "$detected_section" >> CLAUDE.md
     echo "  Created CLAUDE.md"
   fi
 }

package/templates/config/fastmcp.json

@@ -0,0 +1,94 @@
+{
+  "projectType": "fastmcp",
+
+  "auth": {
+    "testUser": "",
+    "testPassword": "",
+    "loginEndpoint": "",
+    "loginMethod": "",
+    "tokenType": "",
+    "tokenHeader": "",
+    "tokenPrefix": ""
+  },
+
+  "docker": {
+    "enabled": true,
+    "composeFile": "docker-compose.yml",
+    "serviceName": "app",
+    "execPrefix": "docker compose exec -T"
+  },
+
+  "paths": {
+    "src": "src",
+    "tests": "tests",
+    "scripts": "scripts"
+  },
+
+  "commands": {
+    "dev": "python -m ${PROJECT_MODULE}.server",
+    "install": "uv pip install -e .",
+    "lint": "ruff check src/",
+    "format": "ruff format src/",
+    "typecheck": "mypy src/",
+    "test": "pytest",
+    "seed": "",
+    "resetDb": ""
+  },
+
+  "checks": {
+    "lint": true,
+    "typecheck": true,
+    "build": false,
+    "test": true,
+    "fastmcp": true
+  },
+
+  "api": {
+    "baseUrl": "http://localhost:8000",
+    "healthEndpoint": "/health",
+    "timeout": 30,
+    "transport": "sse"
+  },
+
+  "mcp": {
+    "transport": "stdio",
+    "serverModule": "",
+    "tools": [],
+    "resources": [],
+    "prompts": []
+  },
+
+  "playwright": {
+    "enabled": false,
+    "testDir": "tests/e2e",
+    "projects": ["chromium"],
+    "baseUrl": "http://localhost:8000"
+  },
+
+  "verification": {
+    "codeReviewEnabled": true,
+    "browserEnabled": false,
+    "mcpEnabled": true,
+    "screenshotOnFailure": false
+  },
+
+  "urls": {
+    "app": "http://localhost:8000",
+    "docs": ""
+  },
+
+  "env": {
+    "required": [],
+    "optional": []
+  },
+
+  "subprojects": {},
+
+  "maxIterations": 20,
+  "maxSessionSeconds": 600,
+
+  "contextRotThreshold": {
+    "maxStories": 10,
+    "maxFilesChanged": 20
+  }
+}