specforge-mcp 0.1.0

package/dist/config/quality-principles.json

@@ -0,0 +1,230 @@
+{
+  "solid": {
+    "name": "SOLID Principles",
+    "applies_to": ["all"],
+    "principles": {
+      "SRP": {
+        "name": "Single Responsibility Principle",
+        "description": "A class/module should have only one reason to change",
+        "detection": ["Files with multiple concerns", "Classes >300 lines", "Functions doing unrelated things"],
+        "fix": "Extract into separate classes/modules with single purpose"
+      },
+      "OCP": {
+        "name": "Open/Closed Principle",
+        "description": "Open for extension, closed for modification",
+        "detection": ["Long switch/if-else chains", "Modifying existing code to add new behavior"],
+        "fix": "Use polymorphism, strategy pattern, or plugin architecture"
+      },
+      "LSP": {
+        "name": "Liskov Substitution Principle",
+        "description": "Subtypes must be substitutable for their base types",
+        "detection": ["Overrides that change behavior contract", "Type checks on subclasses"],
+        "fix": "Ensure subtypes honor the base contract, use composition over inheritance"
+      },
+      "ISP": {
+        "name": "Interface Segregation Principle",
+        "description": "No client should be forced to depend on interfaces it does not use",
+        "detection": ["Interfaces with >7 methods", "Implementations with empty/throw methods"],
+        "fix": "Split into smaller, focused interfaces"
+      },
+      "DIP": {
+        "name": "Dependency Inversion Principle",
+        "description": "Depend on abstractions, not concretions",
+        "detection": ["Direct imports of concrete implementations", "new ClassName() in business logic"],
+        "fix": "Inject dependencies, use interfaces/abstractions"
+      }
+    }
+  },
+  "clean_code": {
+    "name": "Clean Code (Robert C. Martin)",
+    "applies_to": ["all"],
+    "principles": {
+      "meaningful_names": {
+        "name": "Meaningful Names",
+        "description": "Names should reveal intent, be pronounceable, and searchable",
+        "detection": ["Single-letter variables (except loops)", "Abbreviations", "Generic names (data, info, temp)"],
+        "fix": "Use descriptive names that explain why it exists and what it does"
+      },
+      "small_functions": {
+        "name": "Small Functions",
+        "description": "Functions should do one thing, be short (<20 lines ideally), and have few parameters (<3)",
+        "detection": ["Functions >30 lines", ">3 parameters", "Multiple levels of abstraction"],
+        "fix": "Extract helper functions, use objects for parameter groups"
+      },
+      "no_side_effects": {
+        "name": "No Hidden Side Effects",
+        "description": "Functions should not do unexpected things beyond their name",
+        "detection": ["Functions named 'get' that also modify state", "Unexpected mutations"],
+        "fix": "Separate queries from commands (CQS)"
+      },
+      "dry": {
+        "name": "Don't Repeat Yourself",
+        "description": "Every piece of knowledge should have a single, unambiguous representation",
+        "detection": ["Duplicate code blocks", "Copy-pasted logic with minor variations"],
+        "fix": "Extract shared logic into reusable functions/modules"
+      },
+      "yagni": {
+        "name": "You Aren't Gonna Need It",
+        "description": "Don't add functionality until it's needed",
+        "detection": ["Unused abstractions", "Configurable parameters never configured", "Dead code"],
+        "fix": "Remove unused code, simplify to current requirements"
+      },
+      "kiss": {
+        "name": "Keep It Simple, Stupid",
+        "description": "Simplest solution that works is the best",
+        "detection": ["Over-engineered abstractions for simple problems", "Unnecessary design patterns"],
+        "fix": "Reduce complexity, prefer straightforward solutions"
+      },
+      "boy_scout_rule": {
+        "name": "Boy Scout Rule",
+        "description": "Leave the code cleaner than you found it",
+        "detection": ["TODOs older than 30 days", "Known tech debt without tracking"],
+        "fix": "Fix small issues as you encounter them"
+      }
+    }
+  },
+  "design_patterns": {
+    "name": "Design Patterns (Gang of Four + Modern)",
+    "applies_to": ["all"],
+    "patterns": {
+      "creational": ["Factory Method", "Abstract Factory", "Builder", "Singleton (use sparingly)", "Prototype"],
+      "structural": ["Adapter", "Bridge", "Composite", "Decorator", "Facade", "Proxy"],
+      "behavioral": [
+        "Strategy",
+        "Observer",
+        "Command",
+        "State",
+        "Template Method",
+        "Chain of Responsibility",
+        "Mediator"
+      ],
+      "modern": ["Repository", "Unit of Work", "Dependency Injection", "Event Sourcing", "CQRS", "Circuit Breaker"]
+    }
+  },
+  "architecture": {
+    "name": "Architectural Principles",
+    "applies_to": ["all"],
+    "principles": {
+      "separation_of_concerns": {
+        "name": "Separation of Concerns",
+        "description": "Each module addresses a separate concern",
+        "detection": ["UI logic mixed with business logic", "Data access in presentation layer"],
+        "fix": "Organize code into distinct layers with clear boundaries"
+      },
+      "dependency_direction": {
+        "name": "Dependency Direction (Clean Architecture)",
+        "description": "Dependencies point inward — outer layers depend on inner, never reverse",
+        "detection": ["Domain/business logic importing from UI", "Core importing from infrastructure"],
+        "fix": "Invert dependencies, use interfaces at boundaries"
+      },
+      "bounded_contexts": {
+        "name": "Bounded Contexts (DDD)",
+        "description": "Each domain has its own model and language",
+        "detection": ["God models shared across all modules", "Ambiguous terms used differently"],
+        "fix": "Define explicit boundaries between domains"
+      },
+      "ports_and_adapters": {
+        "name": "Ports & Adapters (Hexagonal)",
+        "description": "Core logic is independent of external systems (DB, APIs, UI)",
+        "detection": ["Business logic directly calling DB/API clients", "Framework-specific code in domain"],
+        "fix": "Define ports (interfaces) and adapters (implementations)"
+      },
+      "fail_fast": {
+        "name": "Fail Fast",
+        "description": "Validate inputs and detect errors as early as possible",
+        "detection": ["Late validation deep in the call stack", "Swallowed errors"],
+        "fix": "Validate at system boundaries, propagate errors immediately"
+      },
+      "least_surprise": {
+        "name": "Principle of Least Surprise",
+        "description": "Code should behave as the reader expects",
+        "detection": ["Counterintuitive function names", "Unexpected return types", "Hidden state changes"],
+        "fix": "Follow conventions, be explicit, avoid magic"
+      }
+    }
+  },
+  "security": {
+    "name": "Security Principles (OWASP)",
+    "applies_to": ["all"],
+    "principles": {
+      "input_validation": "Validate and sanitize ALL external inputs",
+      "output_encoding": "Encode output to prevent XSS",
+      "parameterized_queries": "Never concatenate user input into queries",
+      "least_privilege": "Grant minimum permissions necessary",
+      "defense_in_depth": "Multiple layers of security",
+      "secure_defaults": "Secure by default, opt-in to less secure",
+      "no_secrets_in_code": "Never hardcode secrets, use environment variables",
+      "error_handling": "Never expose internal errors to users"
+    }
+  },
+  "testing": {
+    "name": "Testing Principles",
+    "applies_to": ["all"],
+    "principles": {
+      "test_pyramid": "More unit tests, fewer integration, minimal E2E",
+      "arrange_act_assert": "Structure tests clearly: setup, execute, verify",
+      "test_behavior_not_implementation": "Test what the code does, not how",
+      "deterministic": "Tests should always produce the same result",
+      "isolated": "Tests should not depend on each other or external state",
+      "fast": "Unit tests should run in milliseconds",
+      "readable": "Tests are documentation — make them readable"
+    }
+  },
+  "api_design": {
+    "name": "API Design Principles",
+    "applies_to": ["backend", "fullstack"],
+    "principles": {
+      "consistency": "Use consistent naming, patterns, and response formats",
+      "versioning": "Version APIs to avoid breaking changes",
+      "idempotency": "POST/PUT/DELETE should be safe to retry",
+      "pagination": "Always paginate list endpoints",
+      "error_format": "Consistent error response format with codes",
+      "validation": "Validate request bodies with schemas",
+      "documentation": "Every endpoint should be documented"
+    }
+  },
+  "database": {
+    "name": "Database Principles",
+    "applies_to": ["backend", "fullstack"],
+    "principles": {
+      "normalize_then_denormalize": "Start normalized, denormalize only for proven performance needs",
+      "index_queries": "Index columns used in WHERE, JOIN, ORDER BY",
+      "migrations_reversible": "Migrations should be reversible (up + down)",
+      "no_data_loss": "Never drop columns/tables with data without backup strategy",
+      "connection_pooling": "Use connection pools, never open/close per query",
+      "rls": "Row Level Security at database level for multi-tenant"
+    }
+  },
+  "score_weights": {
+    "description": "Weights for calculating QualityScore (SPEC-010). Must sum to 1.0.",
+    "weights": {
+      "solid": 0.25,
+      "clean-code": 0.2,
+      "architecture": 0.2,
+      "security": 0.15,
+      "performance": 0.1,
+      "dry": 0.05,
+      "error-handling": 0.05
+    },
+    "grade_thresholds": {
+      "A": 90,
+      "B": 80,
+      "C": 70,
+      "D": 60,
+      "F": 0
+    }
+  },
+  "frontend": {
+    "name": "Frontend Principles",
+    "applies_to": ["frontend", "fullstack"],
+    "principles": {
+      "component_composition": "Prefer composition over prop drilling",
+      "state_colocation": "Keep state as close to where it's used as possible",
+      "accessibility": "Follow WCAG guidelines, use semantic HTML",
+      "performance_budget": "Track bundle size, LCP, FID, CLS",
+      "responsive": "Mobile-first design approach",
+      "error_boundaries": "Catch and handle errors at component boundaries",
+      "loading_states": "Always handle loading, error, and empty states"
+    }
+  }
+}

package/dist/config/react-nextjs-catalog.json

@@ -0,0 +1,200 @@
+{
+  "_description": "SPEC-051: React 19 + Next.js 16 criteria templates, anti-patterns and tooling catalog.",
+  "serverComponentCriteria": {
+    "_appliesWhen": "routerMode === 'app'",
+    "S2-C4": {
+      "id": "S2-C4",
+      "text": "Components that access DB, external APIs or filesystem MUST be Server Components — no useEffect + fetch for initial data",
+      "rationale": "Server Components run on the server, can access server resources directly and never send JS to the client",
+      "antiPattern": "useEffect(() => { fetch('/api/data').then(...) }, [])",
+      "correctPattern": "async function Page() { const data = await db.query(); return <List items={data} />; }"
+    },
+    "S2-C5": {
+      "id": "S2-C5",
+      "text": "Client Components marked with 'use client' ONLY when they need: local state (useState/useReducer), event listeners, or browser APIs",
+      "rationale": "Unnecessary 'use client' boundaries send more JS to the browser and opt out of RSC benefits",
+      "antiPattern": "'use client'; export function StaticCard({ title }) { return <div>{title}</div>; }",
+      "correctPattern": "// No 'use client' needed — no state, no events, no browser APIs"
+    },
+    "S2-C6": {
+      "id": "S2-C6",
+      "text": "Data mutations implemented as Server Actions ('use server') — not REST endpoints unless external auth is required",
+      "rationale": "Server Actions colocate mutation logic with UI, eliminate round-trip overhead of REST, and are type-safe",
+      "antiPattern": "POST /api/update-user called from client fetch()",
+      "correctPattern": "'use server'; async function updateUser(formData: FormData) { await db.users.update(...); revalidatePath('/profile'); }"
+    }
+  },
+  "cacheCriteria": {
+    "_appliesWhen": "nextjsVersion === '16'",
+    "S3-C7": {
+      "id": "S3-C7",
+      "text": "Functions that fetch data use 'use cache' directive with explicit cacheTag or revalidate parameters — implicit fetch caching prohibited",
+      "rationale": "Next.js 16 deprecated implicit fetch() caching. 'use cache' makes caching explicit and auditable",
+      "antiPattern": "fetch('https://api.example.com/data') // implicitly cached in Next.js 13-15",
+      "correctPattern": "'use cache'; export async function getData() { cacheTag('user-data'); return fetch(...); }"
+    },
+    "S3-C8": {
+      "id": "S3-C8",
+      "text": "Cache invalidation via revalidateTag() for granular invalidation — revalidatePath() only for full static page invalidation",
+      "rationale": "revalidatePath() invalidates all data on a path; revalidateTag() targets specific cached data",
+      "antiPattern": "revalidatePath('/dashboard') // invalidates all cached data on dashboard",
+      "correctPattern": "revalidateTag('user-profile') // invalidates only user profile cache entries"
+    }
+  },
+  "toolingRecommendations": {
+    "react18Migration": {
+      "_appliesWhen": "reactVersion === '18'",
+      "S4-C9": {
+        "id": "S4-C9",
+        "name": "React 19 Migration",
+        "description": "Migrate to React 19 for React Compiler auto-memoization and new APIs",
+        "tools": [
+          {
+            "name": "React Compiler (babel-plugin-react-compiler)",
+            "description": "Auto-memoizes components — eliminates manual memo/useMemo/useCallback",
+            "install": "npm install --save-dev babel-plugin-react-compiler",
+            "docsUrl": "https://react.dev/learn/react-compiler"
+          },
+          {
+            "name": "react-codemod",
+            "description": "Automated codemod for React 19 breaking changes migration",
+            "install": "npx react-codemod",
+            "docsUrl": "https://github.com/reactjs/react-codemod"
+          }
+        ],
+        "breakingChanges": [
+          "ref is now a prop (not forwardRef) — migrate with react-codemod",
+          "use(Promise) replaces useEffect for async data in Client Components",
+          "Async transitions via useTransition — startTransition accepts async functions",
+          "Server Actions stable — no experimental flag needed"
+        ]
+      }
+    },
+    "newProjectReact": {
+      "_appliesWhen": "reactVersion === 'unknown' || reactVersion === '19'",
+      "S4-C10": {
+        "id": "S4-C10",
+        "name": "Next.js 16 + React Compiler Stack",
+        "description": "Recommended stack for new React projects: Next.js 16 App Router with React Compiler",
+        "setup": "npx create-next-app@latest --typescript --app --react-compiler",
+        "tools": [
+          {
+            "name": "Next.js 16",
+            "description": "React framework with App Router, Server Components, and explicit caching",
+            "docsUrl": "https://nextjs.org/docs"
+          },
+          {
+            "name": "React Compiler 1.0",
+            "description": "Stable compiler — enable via experimental.reactCompiler in next.config.ts",
+            "docsUrl": "https://react.dev/learn/react-compiler"
+          },
+          {
+            "name": "Turbopack",
+            "description": "Default bundler in Next.js 16 — 10x faster than Webpack for local dev",
+            "docsUrl": "https://turbo.build/pack"
+          }
+        ]
+      }
+    },
+    "serverActionDecision": {
+      "S4-C11": {
+        "id": "S4-C11",
+        "name": "Server Action vs Route Handler Decision Framework",
+        "description": "Use Server Actions for standard mutations; Route Handlers for external-facing APIs",
+        "useServerAction": [
+          "Form submissions that mutate server-side data",
+          "Mutations triggered from Client Components",
+          "Operations that revalidate cache after mutation",
+          "Progressive enhancement (works without JS)"
+        ],
+        "useRouteHandler": [
+          "Webhooks from external services (Stripe, GitHub, etc.)",
+          "Custom authentication with Authorization headers",
+          "Binary/streaming responses",
+          "REST API consumed by non-Next.js clients"
+        ]
+      }
+    }
+  },
+  "testingTemplates": {
+    "serverComponent": {
+      "_appliesWhen": "no 'use client' directive in component file",
+      "S5-C12": {
+        "id": "S5-C12",
+        "description": "Server Component testing uses async rendering",
+        "imports": ["import { renderAsync } from '@testing-library/react'"],
+        "pattern": "it('renders server component', async () => { const { getByText } = await renderAsync(<MyComponent />); expect(getByText('...')).toBeInTheDocument(); });",
+        "note": "renderAsync handles async Server Component resolution — do NOT use render() synchronously"
+      }
+    },
+    "serverAction": {
+      "_appliesWhen": "file contains 'use server' directive",
+      "S5-C13": {
+        "id": "S5-C13",
+        "description": "Server Action testing mocks Next.js headers/cookies context",
+        "mocks": [
+          "vi.mock('next/headers', () => ({ headers: vi.fn(() => new Headers()), cookies: vi.fn(() => ({ get: vi.fn() })) }))"
+        ],
+        "pattern": "it('executes server action', async () => { vi.mocked(cookies).mockReturnValue({ get: vi.fn().mockReturnValue({ value: 'token' }) }); const result = await myServerAction(formData); expect(result.success).toBe(true); });",
+        "note": "next/headers context is only available server-side — always mock in tests"
+      }
+    },
+    "reactCompilerNote": {
+      "_appliesWhen": "reactCompilerEnabled === true",
+      "S5-C14": {
+        "id": "S5-C14",
+        "description": "React Compiler projects — omit manual memoization wrappers in tests",
+        "note": "React Compiler 1.0 auto-memoizes components. Do NOT wrap test subjects with memo(), useMemo() or useCallback() — the compiler handles this. Testing memoization behavior separately is an anti-pattern.",
+        "antiPattern": "render(<React.memo(MyComponent) />)",
+        "correctPattern": "render(<MyComponent />)"
+      }
+    }
+  },
+  "antiPatterns": {
+    "S6-C15": {
+      "id": "S6-C15",
+      "name": "useEffect data fetch in App Router",
+      "severity": "warning",
+      "description": "useEffect with fetch for initial data in App Router components should be Server Components",
+      "detection": {
+        "patterns": ["useEffect.*fetch\\(", "useEffect.*axios\\.", "useEffect.*=>.*\\.(get|post)\\("],
+        "excludeIfContains": ["'use client'"],
+        "filePatterns": ["app/**/*.tsx", "app/**/*.ts", "src/app/**/*.tsx", "src/app/**/*.ts"]
+      },
+      "suggestion": "Convert to async Server Component: remove useEffect and fetch, use async/await directly in component body"
+    },
+    "S6-C16": {
+      "id": "S6-C16",
+      "name": "memo() with React Compiler active",
+      "severity": "info",
+      "description": "React.memo() wrapping is redundant and potentially conflicting when React Compiler is active",
+      "detection": {
+        "patterns": ["React\\.memo\\(", "memo\\([A-Z]"],
+        "requiresReactCompiler": true
+      },
+      "suggestion": "Remove React.memo() wrapper — React Compiler 1.0 auto-memoizes components and their props"
+    },
+    "S6-C17": {
+      "id": "S6-C17",
+      "name": "Missing Suspense for use(Promise)",
+      "severity": "error",
+      "description": "Components using use(Promise) must be wrapped in <Suspense> — missing boundary causes runtime error",
+      "detection": {
+        "patterns": ["use\\(.*Promise", "use\\(.*promise", "const .* = use\\("],
+        "missingSibling": "<Suspense"
+      },
+      "suggestion": "Wrap the component with <Suspense fallback={<Loading />}> in its parent component"
+    },
+    "S6-C18": {
+      "id": "S6-C18",
+      "name": "React Compiler incompatible with class components",
+      "severity": "warning",
+      "description": "compilationMode: 'all' in React Compiler config is incompatible with class components",
+      "detection": {
+        "configPatterns": ["compilationMode.*['\"]all['\"]"],
+        "codePatterns": ["extends.*Component", "extends.*PureComponent"]
+      },
+      "suggestion": "Set compilationMode: 'annotation' and add // @compilable to function components, or migrate class components to function components"
+    }
+  }
+}

package/dist/config/resilience-patterns.json

@@ -0,0 +1,130 @@
+{
+  "libraries": [
+    {
+      "language": "java",
+      "name": "resilience4j",
+      "detectionPatterns": ["resilience4j", "io.github.resilience4j"],
+      "patterns": ["circuit-breaker", "retry", "rate-limiter", "bulkhead", "fallback"],
+      "annotations": ["@CircuitBreaker", "@Retry", "@RateLimiter", "@Bulkhead", "@TimeLimiter"],
+      "defaults": {
+        "circuitBreaker": { "failureRateThreshold": 50, "openStateDurationMs": 60000 },
+        "retry": { "maxAttempts": 3, "backoffStrategy": "exponential", "baseDelayMs": 500 }
+      }
+    },
+    {
+      "language": "java",
+      "name": "hystrix",
+      "detectionPatterns": ["hystrix", "com.netflix.hystrix"],
+      "status": "legacy",
+      "migrationNote": "Hystrix is in maintenance mode since 2018. Migrate to Resilience4j.",
+      "patterns": ["circuit-breaker", "fallback", "bulkhead"]
+    },
+    {
+      "language": "java",
+      "name": "spring-retry",
+      "detectionPatterns": ["spring-retry", "org.springframework.retry"],
+      "patterns": ["retry"],
+      "annotations": ["@Retryable", "@Recover"]
+    },
+    {
+      "language": "dotnet",
+      "name": "polly",
+      "detectionPatterns": ["Polly", "Microsoft.Extensions.Http.Polly"],
+      "patterns": ["circuit-breaker", "retry", "timeout", "bulkhead", "fallback", "cache"],
+      "apiStyle": "fluent-builder",
+      "defaults": {
+        "circuitBreaker": { "failureRateThreshold": 50, "openStateDurationMs": 30000 },
+        "retry": { "maxAttempts": 3, "backoffStrategy": "exponential", "baseDelayMs": 200 }
+      }
+    },
+    {
+      "language": "python",
+      "name": "stamina",
+      "detectionPatterns": ["stamina"],
+      "patterns": ["retry"],
+      "note": "Modern, opinionated: exponential backoff with jitter by default, integrated with structlog",
+      "defaults": {
+        "retry": { "maxAttempts": 10, "backoffStrategy": "exponential", "baseDelayMs": 100 }
+      }
+    },
+    {
+      "language": "python",
+      "name": "tenacity",
+      "detectionPatterns": ["tenacity"],
+      "patterns": ["retry"],
+      "apiStyle": "decorator",
+      "defaults": {
+        "retry": { "maxAttempts": 3, "backoffStrategy": "exponential", "baseDelayMs": 1000 }
+      }
+    },
+    {
+      "language": "python",
+      "name": "pybreaker",
+      "detectionPatterns": ["pybreaker"],
+      "patterns": ["circuit-breaker"],
+      "defaults": {
+        "circuitBreaker": { "failureRateThreshold": 50, "openStateDurationMs": 60000 }
+      }
+    },
+    {
+      "language": "go",
+      "name": "failsafe-go",
+      "detectionPatterns": ["failsafe-go", "github.com/failsafe-go/failsafe-go"],
+      "patterns": ["circuit-breaker", "retry", "timeout", "bulkhead", "fallback"],
+      "apiStyle": "policy-composition",
+      "defaults": {
+        "circuitBreaker": { "failureRateThreshold": 50, "openStateDurationMs": 30000 },
+        "retry": { "maxAttempts": 3, "backoffStrategy": "exponential", "baseDelayMs": 100 }
+      }
+    },
+    {
+      "language": "go",
+      "name": "gobreaker",
+      "detectionPatterns": ["gobreaker", "github.com/sony/gobreaker"],
+      "patterns": ["circuit-breaker"],
+      "defaults": {
+        "circuitBreaker": { "failureRateThreshold": 60, "openStateDurationMs": 60000 }
+      }
+    },
+    {
+      "language": "nodejs",
+      "name": "opossum",
+      "detectionPatterns": ["opossum"],
+      "patterns": ["circuit-breaker", "fallback"],
+      "note": "Event-based: emits events 'open', 'close', 'halfOpen', 'fallback', 'reject'",
+      "defaults": {
+        "circuitBreaker": { "failureRateThreshold": 50, "openStateDurationMs": 10000 }
+      }
+    },
+    {
+      "language": "nodejs",
+      "name": "p-retry",
+      "detectionPatterns": ["p-retry"],
+      "patterns": ["retry"],
+      "defaults": {
+        "retry": { "maxAttempts": 5, "backoffStrategy": "exponential", "baseDelayMs": 1000 }
+      }
+    },
+    {
+      "language": "nodejs",
+      "name": "cockatiel",
+      "detectionPatterns": ["cockatiel"],
+      "patterns": ["circuit-breaker", "retry", "timeout", "bulkhead", "fallback"],
+      "apiStyle": "policy-composition",
+      "note": "Inspired by Polly .NET, the most complete for Node.js",
+      "defaults": {
+        "retry": { "maxAttempts": 3, "backoffStrategy": "exponential", "baseDelayMs": 300 }
+      }
+    },
+    {
+      "language": "rust",
+      "name": "tokio-retry",
+      "detectionPatterns": ["tokio-retry"],
+      "patterns": ["retry"],
+      "strategies": ["Fixed", "Exponential", "Fibonacci"],
+      "defaults": {
+        "retry": { "maxAttempts": 3, "backoffStrategy": "exponential", "baseDelayMs": 100 }
+      }
+    }
+  ]
+}