create-claude-webapp 1.0.0

package/.husky/pre-commit

@@ -0,0 +1 @@
+npx lint-staged

package/.husky/pre-push

@@ -0,0 +1,3 @@
+#!/bin/sh
+npm run check
+npm run build 

package/.madgerc

@@ -0,0 +1,14 @@
+{
+  "fileExtensions": ["ts"],
+  "excludeRegExp": [
+    "__tests__",
+    "\\.test\\.ts$",
+    "\\.spec\\.ts$"
+  ],
+  "detectiveOptions": {
+    "ts": {
+      "skipTypeImports": true
+    }
+  },
+  "tsConfig": "./tsconfig.json"
+}

package/.tsprunerc

@@ -0,0 +1,11 @@
+{
+  "ignore": [
+    "src/index.ts",
+    "**/__tests__/**",
+    "**/*.test.ts",
+    "**/*.spec.ts",
+    "**/test/**",
+    "**/vitest.config.ts",
+    "**/vitest.setup.ts"
+  ]
+}

package/CLAUDE.md

@@ -0,0 +1,102 @@
+# Claude Code Development Rules
+
+Core rules for maximizing AI execution accuracy. All instructions must follow this file.
+
+## 🚨 Most Important Principle: Research OK, Implementation STOP
+
+**User approval is mandatory before using any Edit/Write/MultiEdit tools**
+
+Reason: To prevent implementations that differ from user intent and ensure correct direction
+
+## Mandatory Execution Process
+
+### Execution Flow (Required Steps)
+1. **Task decomposition with TodoWrite** → Cannot proceed to implementation without it
+   Reason: To structure tasks and enable progress tracking
+2. **Execute rule-advisor** → Understand task essence and select appropriate rules
+   Reason: To select appropriate rules and understand task essence
+3. **Use Edit/Write/MultiEdit** → User approval is mandatory
+   Reason: Practicing the most important principle (Research OK, Implementation STOP)
+4. **Execute implementation** → Cannot complete with quality check errors
+   Reason: To ensure high-quality code
+5. **Count file changes** → Auto-stop when threshold exceeded
+   Reason: To get confirmation before impact becomes too large
+
+### TodoWrite and Metacognition Integration
+**Execution Rules**:
+- When `pending → in_progress`: rule-advisor output is mandatory
+- **After rule-advisor execution**: Always update TodoWrite in the following format
+  1. Add metaCognitiveGuidance.firstStep as the first task in Todo
+  2. Record metaCognitiveGuidance.taskEssence as the completion criteria for each task
+  3. Record warningPatterns as checkpoints during execution
+- Using Edit tools without TodoWrite: Stop as rule violation
+- When updating task status: Recording implementation details is mandatory (no blanks)
+
+### Execution Prerequisites
+1. **rule-advisor agent execution (invoke using Task tool)** → JSON response must exist
+2. **TodoWrite task** → in_progress status must exist
+3. **User approval record** → Explicit approval before Edit/Write
+4. **Quality check results** → Cannot complete with errors > 0
+
+### Required Alternative Patterns
+- **Instead of any type** → Use unknown type with type guards
+  Reason: To ensure type safety and prevent runtime errors
+- **When using Edit** → Always precede with TodoWrite for task management
+  Reason: To enable progress tracking and quality assurance
+- **When using Edit/Write/MultiEdit** → Obtain user approval before execution
+  Reason: To comply with the most important principle (Research OK, Implementation STOP)
+- **When declaring completion** → Confirm zero quality check errors before declaration
+  Reason: To merge only complete code
+
+## Metacognitive Execution (Mandatory at Task Start)
+
+### Metacognition with Information from rule-advisor
+1. **Understand taskEssence (task essence)**
+   - Distinguish between surface work and fundamental purpose
+   - Judge "quick fix" vs "proper solution"
+
+2. **Confirm selectedSkills (applicable skills)**
+   - Judge if selected skills are appropriate
+   - Load necessary sections
+
+3. **Recognize metaCognitiveGuidance.pastFailures (past failures)**
+   - Be careful not to repeat same failures
+   - Be conscious of suggested workarounds
+
+4. **Execute metaCognitiveGuidance.firstStep (initial action)**
+   - Start with recommended tools
+   - Proceed systematically
+
+## Claude Behavior Control (Failure Prevention)
+
+### Auto-stop Triggers (Must Stop)
+- **Detecting 5+ file changes**: Stop immediately, report impact to user
+  Reason: Large changes require advance planning and review
+- **Same error occurs 3 times**: Root cause analysis mandatory
+  Reason: Need root solution, not symptomatic treatment
+- **Detecting excessive unknown type usage**: Reconsider type guard design
+  Reason: High possibility of type safety design issues
+- **After editing 3 files**: Force TodoWrite update (cannot use next Edit tool without update)
+  Reason: Need to confirm progress and direction
+
+### Handling Error-fixing Impulse
+1. Error discovered → **Pause**
+2. Re-execute rule-advisor
+3. Root cause analysis (repeat "why" 5 times to identify true cause)
+4. Present action plan
+5. Fix after user approval
+
+### Escalation Criteria (User Confirmation Required)
+- Architecture changes (adding new layers, changing responsibilities)
+- Adding external dependencies (npm packages, external APIs)
+- Breaking changes (changing existing APIs, data structures)
+- Multiple implementation methods with unclear superiority
+
+### Preventing Rule Ignoring When Focused
+**Measurable Forced Stop Criteria**:
+- **2nd consecutive error fix**: Automatically trigger rule-advisor re-execution
+- **5 Edit tool uses**: Force impact report creation
+- **3 edits to same file**: Force stop for refactoring consideration
+
+### Temporary File Creation Rules
+Use `tmp/` directory for work files. Delete upon completion.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shinsuke Kagawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,322 @@
+# AI Coding Project Boilerplate 🤖
+
+*Read this in other languages: [日本語](README.ja.md)*
+
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue?logo=typescript)](https://www.typescriptlang.org/)
+[![Node.js](https://img.shields.io/badge/Node.js-20%2B-green?logo=node.js)](https://nodejs.org/)
+[![Claude Code](https://img.shields.io/badge/Claude%20Code-Optimized-purple)](https://claude.ai/code)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](https://github.com/svenmalvik/claude-boilerplate-4-web/pulls)
+
+⚡ **This boilerplate is for developers who want to:**
+- Build **production-ready TypeScript projects** faster with AI
+- Avoid **context exhaustion** in long AI coding sessions
+- Standardize team workflows with **specialized AI agents**
+
+## 📖 Table of Contents
+1. [Quick Start (3 Steps)](#-quick-start-3-steps)
+2. [Why Sub Agents?](#-why-sub-agents)
+3. [Skills System](#-skills-system)
+4. [Real Projects & Results](#-real-world-results)
+5. [Documentation & Guides](#-documentation--guides)
+6. [Slash Commands](#-slash-commands)
+7. [Development Workflow](#-claude-code-workflow)
+8. [Project Structure](#-project-structure)
+9. [Package Manager Configuration](#-package-manager-configuration)
+10. [Multilingual Support](#-multilingual-support)
+11. [FAQ](#-faq)
+
+## ⚡ Quick Start (3 Steps)
+
+```bash
+# 1. Create your project (30 seconds)
+npx create-ai-project my-project
+
+# 2. Install dependencies (automatic)
+cd my-project && npm install
+
+# 3. Launch Claude Code and configure
+claude                    # Launch Claude Code
+/project-inject          # Configure project context
+/implement <your feature> # Start building!
+```
+
+> 💡 **First time?** Check the [Quick Start Guide](docs/guides/en/quickstart.md) for detailed setup instructions
+
+## 🚀 Why Sub Agents?
+
+**Traditional AI coding struggles with:**
+- ❌ Losing context in long sessions
+- ❌ Declining code quality over time  
+- ❌ Frequent session restarts for large tasks
+
+**Sub agents solve this by:**
+- ✅ Splitting work into specialized roles (design, implementation, review)
+- ✅ Keeping context fresh and quality consistent
+- ✅ Handling large projects without degradation
+
+Each agent focuses on one thing and does it well. No context exhaustion, no quality drop.
+
+👉 [Learn more about Sub Agents (Anthropic docs)](https://docs.anthropic.com/en/docs/claude-code/sub-agents)
+
+## 🎨 Skills System
+
+This boilerplate provides the principles used in agentic implementation workflows as skills, making them available for reference in everyday tasks as needed.
+
+### Applied Skills
+
+| Skill | Purpose |
+|-------|---------|
+| `coding-standards` | Universal coding principles, anti-patterns, debugging |
+| `typescript-rules` | TypeScript type safety, async patterns, refactoring |
+| `typescript-testing` | Vitest, TDD, coverage requirements |
+| `documentation-criteria` | PRD, ADR, Design Doc standards |
+| `technical-spec` | Architecture, environment, build commands |
+| `implementation-approach` | Strategy patterns, task decomposition |
+| `integration-e2e-testing` | Integration/E2E test design, ROI-based selection |
+| `project-context` | Project-specific configuration (customizable) |
+| `supabase` | Database design, RLS policies, type generation |
+| `supabase-edge-functions` | Edge Functions with Deno runtime |
+| `supabase-local` | Local development, CLI, migrations |
+| `supabase-testing` | Testing Supabase with Vitest |
+| `stack-auth` | Authentication flows, MCP server integration |
+| `vercel-deployment` | Vercel config, environment variables |
+| `vercel-edge` | Edge runtime, middleware patterns |
+| `fullstack-integration` | Cross-service integration patterns |
+| `subagents-orchestration-guide` | Subagent coordination and distribution |
+| `task-analyzer` | Task essence analysis, skill selection |
+| `interview` | Technical interview & spec generation |
+
+**Frontend-specific skills** are also available under `frontend/` (e.g., `frontend/typescript-rules`).
+
+👉 [Learn how Skills work (Claude Code docs)](https://code.claude.com/docs/en/skills)
+
+## 🎯 Real-World Results
+
+### ⏱️ Time Comparison
+- **Without this boilerplate**: ~1 week for setup + infrastructure
+- **With this boilerplate**: ~2 days to production-ready application
+
+## 📚 Documentation & Guides
+
+- **[Quick Start Guide](docs/guides/en/quickstart.md)** - Get running in 5 minutes
+- **[Use Cases & Commands](docs/guides/en/use-cases.md)** - Daily workflow reference
+- **[Rule Editing Guide](docs/guides/en/rule-editing-guide.md)** - Customize for your project
+
+## 📝 Slash Commands
+
+Essential commands for Claude Code:
+
+| Command | Purpose | When to Use |
+|---------|---------|-------------|
+| `/implement` | End-to-end feature development | New features (Backend) |
+| `/task` | Single task with rule precision | Bug fixes, small changes |
+| `/design` | Create design docs only | Architecture planning (Backend) |
+| `/plan` | Create work plan from design | After design approval (Backend) |
+| `/build` | Execute from existing plan | Resume work (Backend) |
+| `/review` | Check code compliance | Post-implementation (Backend) |
+| `/front-design` | Create frontend design docs | React/Vite architecture planning |
+| `/front-plan` | Create frontend work plan | After frontend design approval |
+| `/front-build` | Execute frontend implementation | React component development |
+| `/front-review` | Check frontend code compliance | Post-implementation (Frontend) |
+| `/diagnose` | Root cause analysis workflow | Debugging, troubleshooting |
+| `/reverse-engineer` | Generate PRD/Design Docs from code | Legacy system documentation (Backend) |
+| `/front-reverse-design` | Generate frontend Design Docs | Existing frontend code documentation |
+| `/add-integration-tests` | Add integration/E2E tests | When Design Doc exists but tests missing |
+| `/setup-supabase` | Initialize Supabase in project | New project with Supabase |
+| `/setup-vercel` | Initialize Vercel configuration | Deploying to Vercel |
+| `/setup-auth` | Initialize Stack-auth integration | Adding authentication |
+| `/deploy` | Orchestrate full deployment | Production deployment |
+| `/db-migrate` | Create/run database migrations | Schema changes |
+| `/local-dev` | Start local development environment | Local development |
+| `/refine-skill` | Implement skill change requests | Customizing skills |
+| `/sync-skills` | Synchronize skill metadata | After skill edits |
+
+[Full command reference →](docs/guides/en/use-cases.md)
+
+## 🤖 Claude Code Workflow
+
+```mermaid
+graph LR
+    A[Requirements] --> B[Scale Detection]
+    B -->|Small| C[Direct Implementation]
+    B -->|Medium| D[Design → Implementation]
+    B -->|Large| E[PRD → Design → Implementation]
+
+    C --> F[Quality Check → Commit]
+    D --> F
+    E --> F
+```
+
+### Reverse Engineering Workflow
+
+Generate PRD and Design Docs from existing code:
+
+```mermaid
+graph TB
+    subgraph Phase1[Phase 1: PRD Generation]
+        CMD["/reverse-engineer"] --> SD1[scope-discoverer]
+        SD1 --> PRD[prd-creator]
+        PRD --> CV1[code-verifier]
+        CV1 --> DR1[document-reviewer]
+    end
+
+    subgraph Phase2[Phase 2: Design Doc Generation]
+        SD2[scope-discoverer] --> DD[technical-designer]
+        DD --> CV2[code-verifier]
+        CV2 --> DR2[document-reviewer]
+        DR2 --> DONE[Complete]
+    end
+
+    DR1 --> |All PRDs Approved| SD2
+```
+
+### How It Works
+
+1. **Requirement Analysis**: `/implement` command analyzes task scale
+2. **Document Generation**: Creates necessary docs (PRD, Design Doc, Work Plan)
+3. **Task Execution**: Specialized agents handle each phase
+4. **Quality Assurance**: Automatic testing, type checking, and fixes
+5. **Commit & Continue**: Clean commits for each completed task
+
+## 📂 Project Structure
+
+```
+claude-boilerplate-4-web/
+├── .claude/               # AI agent configurations
+│   ├── agents/           # Specialized sub-agent definitions
+│   ├── commands/         # Slash command definitions
+│   └── skills/           # Skills for automatic context loading
+│       ├── coding-standards/       # Universal coding principles
+│       ├── typescript-rules/       # TypeScript type safety
+│       ├── typescript-testing/     # Vitest, TDD standards
+│       ├── documentation-criteria/ # PRD, ADR, Design Doc standards
+│       ├── technical-spec/         # Architecture, build commands
+│       ├── implementation-approach/# Strategy patterns
+│       ├── integration-e2e-testing/# E2E test design
+│       ├── project-context/        # Project-specific config
+│       ├── supabase/               # Supabase database design
+│       ├── supabase-edge-functions/# Edge Functions (Deno)
+│       ├── supabase-local/         # Local development
+│       ├── supabase-testing/       # Testing Supabase
+│       ├── stack-auth/             # Authentication flows
+│       ├── vercel-deployment/      # Vercel config
+│       ├── vercel-edge/            # Edge runtime
+│       ├── fullstack-integration/  # Cross-service patterns
+│       ├── subagents-orchestration-guide/
+│       ├── task-analyzer/          # Task analysis
+│       ├── interview/              # Technical interviews
+│       └── frontend/               # Frontend-specific skills
+├── docs/
+│   ├── guides/           # User documentation
+│   ├── adr/              # Architecture decisions
+│   ├── design/           # Design documents
+│   └── prd/              # Product requirements
+├── src/                  # Your source code
+├── scripts/              # Utility scripts
+└── CLAUDE.md             # Claude Code configuration
+```
+
+## 🔧 Package Manager Configuration
+
+This boilerplate uses npm by default, but you can switch to your preferred package manager like bun or pnpm.
+
+There are two environment-dependent settings in `package.json`:
+
+- **`packageManager`**: The package manager and version to use
+- **`scripts`**: The execution commands for each script
+
+When you change these, Claude Code will recognize them and execute with the appropriate commands.
+
+### Switching to bun
+
+```json
+{
+  "packageManager": "bun@1.3.3",
+  "scripts": {
+    "build": "bun run tsc && tsc-alias",
+    "dev": "bun run src/index.ts",
+    "test": "bun test",
+    "check": "bunx @biomejs/biome check src",
+    "check:all": "bun run check && bun run lint && bun run format:check && bun run check:unused && bun run check:deps && bun run build && bun test"
+  }
+}
+```
+
+The above are representative examples. The following scripts are referenced in rules and sub-agent definitions. Update them as needed:
+
+`build`, `build:frontend`, `dev`, `preview`, `type-check`, `test`, `test:coverage`, `test:coverage:fresh`, `test:safe`, `cleanup:processes`, `check`, `check:fix`, `check:code`, `check:unused`, `check:deps`, `check:all`, `format`, `format:check`, `lint`, `lint:fix`
+
+## 🌐 Multilingual Support
+
+Full support for English and Japanese:
+
+```bash
+npm run lang:en         # Switch to English
+npm run lang:ja         # Switch to Japanese
+npm run lang:status     # Check current language
+```
+
+Automatically updates all configurations, rules, and agent definitions.
+
+## 🤔 FAQ
+
+**Q: How do sub agents work?**  
+A: Just use `/implement` or `/task`. The right agents activate automatically.
+
+**Q: What if there are errors?**  
+A: quality-fixer auto-fixes most issues. If not, it provides clear instructions.
+
+**Q: Can I customize for my project?**  
+A: Yes! Run `/project-inject` to configure project-specific context.
+
+**Q: What's the typical workflow?**  
+A: `/project-inject` (once) → `/implement` (features) → auto quality checks → commit
+
+**Q: How is this different from Copilot/Cursor?**  
+A: Those help write code. This manages entire development lifecycle with specialized agents.
+
+## 🤖 Complete Sub Agents Roster
+
+| Agent | Specialization | Activation |
+|-------|---------------|------------|
+| **requirement-analyzer** | Scale assessment | Start of `/implement` |
+| **prd-creator** | PRD and business requirements | Large features |
+| **technical-designer** | Design documentation | Medium/large features |
+| **technical-designer-frontend** | Frontend design docs | React architecture planning |
+| **document-reviewer** | Document quality check | After document creation |
+| **design-sync** | Design Doc consistency | After Design Doc creation |
+| **acceptance-test-generator** | Test skeleton from ACs | After design approval |
+| **work-planner** | Task breakdown | After design approval |
+| **task-decomposer** | Single-commit task splitting | After work plan creation |
+| **rule-advisor** | Optimal ruleset selection | Before any implementation |
+| **task-executor** | Backend implementation | During build phase |
+| **task-executor-frontend** | React implementation | Frontend build phase |
+| **quality-fixer** | Backend automated fixes | On any quality issue |
+| **quality-fixer-frontend** | Frontend automated fixes | On React quality issues |
+| **code-reviewer** | Compliance check | `/review` command |
+| **integration-test-reviewer** | Test implementation quality | After test implementation |
+| **investigator** | Problem investigation | `/diagnose` Step 1 |
+| **verifier** | Investigation verification | `/diagnose` Step 3 |
+| **solver** | Solution derivation | `/diagnose` Step 4 |
+| **scope-discoverer** | PRD/Design Doc scope discovery | `/reverse-engineer` Step 1 |
+| **code-verifier** | Document-code consistency | `/reverse-engineer` verification |
+| **supabase-migration-generator** | Type-safe migrations | `/db-migrate` command |
+| **rls-policy-designer** | Row Level Security design | Supabase security setup |
+| **auth-flow-designer** | Stack-auth flows | `/setup-auth` command |
+| **deployment-executor** | Vercel deployments | `/deploy` command |
+| **environment-validator** | Env config validation | Before deployment |
+
+[Full agent list →](.claude/agents/)
+
+## 📄 License
+
+MIT License - Free to use, modify, and distribute
+
+## 🎯 About This Project
+
+The AI Coding Project Boilerplate is engineered to maximize AI coding productivity while maintaining human-level code quality. By leveraging specialized sub agents and context engineering, it enables teams to build production-ready TypeScript applications at unprecedented speed.
+
+---
+
+Happy Coding with Claude Code! 🤖✨

package/bin/create-project.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+  console.log(`
+🚀 AI Coding Project Boilerplate
+
+Usage:
+  npx create-ai-project <project-name> [options]
+  npm init ai-project <project-name> [options]
+
+Options:
+  --lang=<language>  Set the project language (ja or en, default: en)
+  --help, -h         Show this help message
+
+Examples:
+  npx create-ai-project my-project
+  npx create-ai-project my-project --lang=ja
+  npm init ai-project my-project --lang=ja
+  `);
+  process.exit(0);
+}
+
+const projectName = args[0];
+const options = args.slice(1);
+
+// Parse language option
+let language = 'en'; // default
+for (const opt of options) {
+  if (opt.startsWith('--lang=')) {
+    language = opt.split('=')[1];
+    if (!['ja', 'en'].includes(language)) {
+      console.error(`❌ Invalid language: ${language}. Supported languages are: ja, en`);
+      process.exit(1);
+    }
+  }
+}
+
+// Validate project name
+const validNamePattern = /^[a-z0-9-._]+$/;
+if (!validNamePattern.test(projectName)) {
+  console.error(`❌ Invalid project name: ${projectName}`);
+  console.error('   Project name must contain only lowercase letters, numbers, hyphens, dots, and underscores.');
+  process.exit(1);
+}
+
+// Check if directory already exists
+const projectPath = path.resolve(process.cwd(), projectName);
+if (fs.existsSync(projectPath)) {
+  console.error(`❌ Directory already exists: ${projectPath}`);
+  process.exit(1);
+}
+
+console.log(`\n🎉 Creating new AI coding project: ${projectName}`);
+console.log(`📍 Location: ${projectPath}`);
+console.log(`🌐 Language: ${language}\n`);
+
+// Run setup script
+const setupScript = path.join(__dirname, '..', 'scripts', 'setup-project.js');
+const setupProcess = spawn('node', [setupScript, projectName, language], {
+  stdio: 'inherit',
+  cwd: process.cwd()  // 現在の作業ディレクトリを使用
+});
+
+setupProcess.on('close', (code) => {
+  if (code !== 0) {
+    console.error(`\n❌ Setup failed with exit code ${code}`);
+    process.exit(code);
+  }
+  
+  console.log(`\n✅ Project created successfully!`);
+  console.log(`\n📖 Next steps:`);
+  console.log(`   cd ${projectName}`);
+  console.log(`   npm install`);
+  console.log(`   npm run dev\n`);
+});
+
+setupProcess.on('error', (err) => {
+  console.error(`\n❌ Failed to execute setup script: ${err.message}`);
+  process.exit(1);
+});

package/biome.json

@@ -0,0 +1,51 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "formatter": {
+    "enabled": true,
+    "formatWithErrors": false,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "style": {
+        "noNonNullAssertion": "off"
+      },
+      "suspicious": {
+        "noExplicitAny": "warn"
+      },
+      "complexity": {
+        "useLiteralKeys": "off"
+      }
+    }
+  },
+  "overrides": [
+    {
+      "include": ["**/__tests__/**/*.ts", "**/*.test.ts", "**/*.spec.ts"],
+      "linter": {
+        "rules": {
+          "suspicious": {
+            "noExplicitAny": "off"
+          }
+        }
+      }
+    }
+  ],
+  "javascript": {
+    "formatter": {
+      "semicolons": "asNeeded",
+      "quoteStyle": "single",
+      "trailingCommas": "es5"
+    }
+  },
+  "files": {
+    "include": ["src/**/*.ts", "src/**/*.js"],
+    "ignore": ["node_modules/**", "dist/**"]
+  }
+}