xtrm-tools 2.0.0

package/project-skills/service-skills-set/.claude/skills/using-service-skills/scripts/skill_activator.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: skill activator.
+
+Fires before Read, Write, Edit, Glob, Grep, or Bash operations.
+Checks whether the operation touches a registered service territory.
+If it does, injects additionalContext telling Claude to load the skill
+before proceeding — ensuring expert knowledge is always applied.
+
+Configured in .claude/settings.json PreToolUse hook.
+Must be fast: pure file I/O + string matching, no subprocess.
+"""
+
+import fnmatch
+import json
+import sys
+from pathlib import Path
+
+BOOTSTRAP_DIR = Path(__file__).parent.parent.parent / "creating-service-skills" / "scripts"
+sys.path.insert(0, str(BOOTSTRAP_DIR))
+
+from bootstrap import RootResolutionError, get_project_root, load_registry  # noqa: E402
+
+
+def match_territory(file_path: str, territory: list[str], project_root: Path) -> bool:
+    """Check if a file path matches any territory glob pattern."""
+    # Normalize to relative path
+    fp = Path(file_path)
+    if fp.is_absolute():
+        try:
+            fp = fp.relative_to(project_root)
+        except ValueError:
+            return False
+    rel = str(fp)
+
+    for pattern in territory:
+        # fnmatch handles * and ?, but not ** — handle ** manually
+        if "**" in pattern:
+            # Split on **/ and check prefix + suffix
+            parts = pattern.split("**/")
+            if len(parts) == 2:
+                prefix, suffix = parts
+                rel_check = rel[len(prefix) :] if rel.startswith(prefix) else rel
+                if fnmatch.fnmatch(rel_check, suffix) or fnmatch.fnmatch(
+                    rel, f"{prefix}*/{suffix}"
+                ):
+                    return True
+                # Also check if file is anywhere under the prefix dir
+                if prefix and rel.startswith(prefix.rstrip("/")):
+                    return True
+        else:
+            if fnmatch.fnmatch(rel, pattern):
+                return True
+        # Direct prefix match for broad patterns
+        base = pattern.split("/*")[0].split("/**")[0]
+        if base and (rel.startswith(base + "/") or rel == base):
+            return True
+
+    return False
+
+
+def find_service_for_file(
+    file_path: str, services: dict, project_root: Path
+) -> tuple[str, dict] | None:
+    """Return (service_id, service_data) if file is in any territory, else None."""
+    for service_id, data in services.items():
+        if match_territory(file_path, data.get("territory", []), project_root):
+            return service_id, data
+    return None
+
+
+def find_service_for_command(command: str, services: dict) -> tuple[str, dict] | None:
+    """Return (service_id, service_data) if command mentions a service name."""
+    cmd_lower = command.lower()
+    for service_id, data in services.items():
+        # Match service_id directly or as a container name in docker commands
+        if service_id in cmd_lower:
+            return service_id, data
+        # Match the container name pattern (service name with dashes/underscores)
+        if data.get("name") and data.get("name", "").lower().replace(" ", "-") in cmd_lower:
+            return service_id, data
+    return None
+
+
+def build_context(service_id: str, data: dict) -> str:
+    skill_path = data.get("skill_path", f".claude/skills/{service_id}/SKILL.md")
+    desc = data.get("description", "")
+    desc_line = f"\n  What it covers: {desc}" if desc else ""
+
+    return (
+        f"[Service Skill] You are about to work with the '{service_id}' service territory."
+        f"{desc_line}\n"
+        f"  Load the expert skill before proceeding: Read {skill_path}\n"
+        f"  The skill contains: operational knowledge, failure modes, diagnostic scripts, "
+        f"and the correct methods for managing this service.\n"
+        f"  Do not use ad-hoc approaches (raw SQL, improvised docker commands) "
+        f"when the skill defines the correct method."
+    )
+
+
+def main() -> None:
+    try:
+        data = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        sys.exit(0)
+
+    tool_name = data.get("tool_name", "")
+    tool_input = data.get("tool_input", {})
+
+    try:
+        project_root = Path(get_project_root())
+        services = load_registry()
+    except (RootResolutionError, Exception):
+        sys.exit(0)
+
+    if not services:
+        sys.exit(0)
+
+    match = None
+
+    # File-based tools: check file_path against territory
+    if tool_name in ("Read", "Write", "Edit", "Glob", "Grep", "NotebookRead", "NotebookEdit"):
+        file_path = (
+            tool_input.get("file_path")
+            or tool_input.get("path")
+            or tool_input.get("notebook_path")
+            or ""
+        )
+        if file_path:
+            match = find_service_for_file(file_path, services, project_root)
+
+    # Bash: check command string for service names
+    elif tool_name == "Bash":
+        command = tool_input.get("command", "")
+        if command:
+            match = find_service_for_command(command, services)
+
+    if match:
+        service_id, service_data = match
+        output = {
+            "hookSpecificOutput": {
+                "hookEventName": "PreToolUse",
+                "additionalContext": build_context(service_id, service_data),
+            }
+        }
+        print(json.dumps(output))
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/project-skills/service-skills-set/README.md

@@ -0,0 +1,93 @@
+# Service Skills Set
+
+**Service Skills** give Claude persistent, project-specific operational knowledge about your Docker services. Instead of re-explaining your architecture every session, each service gets a dedicated skill package that Claude loads on demand.
+
+## What It Does
+
+### Three Workflow Skills (Trinity)
+
+| Skill | Role | Invocation |
+|-------|------|------------|
+| `creating-service-skills` | Builds new skill packages via 3-phase workflow | `/creating-service-skills` |
+| `using-service-skills` | Discovers and activates expert personas | Auto (SessionStart hook) |
+| `updating-service-skills` | Detects drift when code changes | Auto (PostToolUse hook) |
+
+### Five Hooks
+
+| Hook | Type | Trigger | Effect |
+|------|------|---------|--------|
+| `SessionStart` | Claude Code | Session opens | Injects service catalog (~150 tokens) |
+| `PreToolUse` | Claude Code | Read/Write/Edit/Grep/Glob/Bash | Checks service territory, activates skills |
+| `PostToolUse` | Claude Code | Write/Edit | Detects drift, notifies to sync docs |
+| `pre-commit` | Git | `git commit` | Warns if source changed without SSOT update |
+| `pre-push` | Git | `git push` | Warns if service skills are stale |
+
+## Installation
+
+```bash
+# From your project directory
+xtrm install project service-skills-set
+```
+
+**Post-install:** The Service Skills Set requires Python scripts to be executable. The installer will:
+1. Copy skills to `.claude/skills/`
+2. Wire `settings.json` hooks
+3. Activate git hooks (`pre-commit`, `pre-push`)
+
+## Creating a Service Skill
+
+After installation, invoke the skill in Claude Code:
+
+```bash
+/creating-service-skills
+```
+
+This runs a 3-phase workflow:
+
+### Phase 1: Automated Skeleton
+- Reads `docker-compose*.yml`, `Dockerfile`, dependency files
+- Produces `SKILL.md` with `[PENDING RESEARCH]` markers
+- Generates script stubs in `scripts/`
+- Creates entry in `.claude/skills/service-registry.json`
+
+### Phase 2: Agentic Deep Dive
+- Uses Serena LSP for codebase research (75-80% token savings)
+- Fills `[PENDING RESEARCH]` markers with actual knowledge
+- Sources troubleshooting tables from real failure modes
+
+### Phase 3: Hook Registration
+- Verifies `PreToolUse` hook in `settings.json`
+- Confirms service territory globs in registry
+- Skill now auto-activates on territory file access
+
+## Generated Skill Structure
+
+```
+.claude/skills/<service-name>/
+├── SKILL.md                  — architecture, failure modes, operations
+├── scripts/
+│   ├── health_probe.py       — container status check
+│   ├── log_hunter.py         — log pattern analysis
+│   ├── data_explorer.py      — read-only DB inspection
+│   └── <specialist>.py       — service-type inspector
+└── references/
+    ├── deep_dive.md          — Phase 2 research notes
+    └── architecture_ssot.md  — link to project SSOT
+```
+
+## Auto-Activation
+
+Skills activate automatically when Claude:
+- Operates on files matching territory globs (e.g., `src/auth/**/*.py`)
+- Runs Bash commands mentioning service/container name
+
+## Requirements
+
+- Python 3.8+
+- Git repository
+- Docker Compose project
+
+## Documentation
+
+- Full guide: `.claude/docs/service-skills-set-readme.md`
+- Original: `project-skills/service-skills-set/service-skills-readme.md`

package/project-skills/service-skills-set/install-service-skills.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Install the Service Skill Trinity into the current project.
+
+Run from inside your target project directory:
+    python3 /path/to/jaggers-agent-tools/project-skills/install-service-skills.py
+
+Installs:
+  .claude/skills/creating-service-skills/   — scaffold new service skills
+  .claude/skills/using-service-skills/      — session-start catalog injection
+  .claude/skills/updating-service-skills/   — drift detection on file writes
+  .claude/skills/scoping-service-skills/    — task intake and service routing
+  .claude/settings.json                     — SessionStart + PostToolUse hooks
+  .githooks/pre-commit                      — doc-reminder (non-blocking)
+  .githooks/pre-push                        — skill-staleness (non-blocking)
+  .git/hooks/pre-commit + pre-push          — activated
+
+Idempotent. Safe to re-run.
+"""
+
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+SCRIPT_DIR = Path(__file__).parent.resolve()            # project-skills/service-skills-set/
+REPO_ROOT  = SCRIPT_DIR.parent.parent.resolve()         # jaggers-agent-tools/
+SKILLS_SRC = SCRIPT_DIR / ".claude"                     # service-skills-set/.claude/<skill>/
+GIT_HOOKS  = SKILLS_SRC / "git-hooks"                   # service-skills-set/.claude/git-hooks/
+
+GREEN  = "\033[0;32m"
+YELLOW = "\033[1;33m"
+NC     = "\033[0m"
+
+TRINITY = ["creating-service-skills", "using-service-skills", "updating-service-skills", "scoping-service-skills"]
+
+SETTINGS_HOOKS = {
+    "SessionStart": [
+        {"hooks": [{"type": "command",
+            "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/skills/using-service-skills/scripts/cataloger.py\""}]}
+    ],
+    "PreToolUse": [
+        {"matcher": "Read|Write|Edit|Glob|Grep|Bash",
+         "hooks": [{"type": "command",
+             "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/skills/using-service-skills/scripts/skill_activator.py\""}]}
+    ],
+    "PostToolUse": [
+        {"matcher": "Write|Edit",
+         "hooks": [{"type": "command",
+             "command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/skills/updating-service-skills/scripts/drift_detector.py\" check-hook",
+             "timeout": 10}]}
+    ]
+}
+
+MARKER_DOC       = "# [jaggers] doc-reminder"
+MARKER_STALENESS = "# [jaggers] skill-staleness"
+
+
+def get_project_root() -> Path:
+    try:
+        r = subprocess.run(["git", "rev-parse", "--show-toplevel"],
+                           capture_output=True, text=True, check=True, timeout=5)
+        root = Path(r.stdout.strip())
+        if root == REPO_ROOT:
+            print("Error: run this from inside your TARGET project, not jaggers-agent-tools itself.")
+            sys.exit(1)
+        return root
+    except subprocess.CalledProcessError:
+        print("Error: not inside a git repository.")
+        sys.exit(1)
+
+
+def install_skills(project_root: Path) -> None:
+    print("\n── Skills ──────────────────────────────")
+    for skill in TRINITY:
+        src  = SKILLS_SRC / skill
+        dest = project_root / ".claude" / "skills" / skill
+        if dest.exists():
+            shutil.rmtree(dest)
+        shutil.copytree(src, dest, ignore=shutil.ignore_patterns("*.Zone.Identifier"))
+        print(f"{GREEN}  ✓{NC} .claude/skills/{skill}/")
+
+
+def install_settings(project_root: Path) -> None:
+    print("\n── settings.json ───────────────────────")
+    path = project_root / ".claude" / "settings.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    existing = {}
+    if path.exists():
+        try:
+            existing = json.loads(path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            pass
+
+    hooks = existing.setdefault("hooks", {})
+    for event, config in SETTINGS_HOOKS.items():
+        if event not in hooks:
+            hooks[event] = config
+            print(f"{GREEN}  ✓{NC} added hook: {event}")
+        else:
+            print(f"{YELLOW}  ○{NC} hook already present: {event} (not overwritten)")
+
+    path.write_text(json.dumps(existing, indent=2) + "\n", encoding="utf-8")
+
+
+def install_git_hooks(project_root: Path) -> None:
+    print("\n── Git hooks ───────────────────────────")
+    doc_script      = GIT_HOOKS / "doc_reminder.py"
+    staleness_script = GIT_HOOKS / "skill_staleness.py"
+
+    pre_commit = project_root / ".githooks" / "pre-commit"
+    pre_push   = project_root / ".githooks" / "pre-push"
+
+    for hp in (pre_commit, pre_push):
+        if not hp.exists():
+            hp.parent.mkdir(parents=True, exist_ok=True)
+            hp.write_text("#!/usr/bin/env bash\n", encoding="utf-8")
+            hp.chmod(0o755)
+
+    snippets = [
+        (pre_commit, MARKER_DOC,
+         f"\n{MARKER_DOC}\nif command -v python3 &>/dev/null && [ -f \"{doc_script}\" ]; then\n    python3 \"{doc_script}\" || true\nfi\n"),
+        (pre_push, MARKER_STALENESS,
+         f"\n{MARKER_STALENESS}\nif command -v python3 &>/dev/null && [ -f \"{staleness_script}\" ]; then\n    python3 \"{staleness_script}\" || true\nfi\n"),
+    ]
+
+    changed = False
+    for hook_path, marker, snippet in snippets:
+        content = hook_path.read_text(encoding="utf-8")
+        if marker not in content:
+            hook_path.write_text(content + snippet, encoding="utf-8")
+            print(f"{GREEN}  ✓{NC} {hook_path.relative_to(project_root)}")
+            changed = True
+        else:
+            print(f"{YELLOW}  ○{NC} already installed: {hook_path.name}")
+
+    if changed:
+        git_dir = project_root / ".git" / "hooks"
+        git_dir.mkdir(parents=True, exist_ok=True)
+        for src, name in ((pre_commit, "pre-commit"), (pre_push, "pre-push")):
+            if src.exists():
+                dest = git_dir / name
+                shutil.copy2(src, dest)
+                dest.chmod(0o755)
+        print(f"{GREEN}  ✓{NC} activated in .git/hooks/")
+
+
+def main() -> None:
+    project_root = get_project_root()
+    print(f"Installing into: {project_root}")
+
+    install_skills(project_root)
+    install_settings(project_root)
+    install_git_hooks(project_root)
+
+    print(f"\n{GREEN}Done.{NC}")
+    print(f"  Hooks active: SessionStart (catalog) · PreToolUse (skill activator) · PostToolUse (drift) · pre-commit · pre-push")
+
+
+if __name__ == "__main__":
+    main()

package/project-skills/service-skills-set/service-skills-readme.md

@@ -0,0 +1,236 @@
+# Service Skills
+
+A system that gives Claude persistent, project-specific operational knowledge about your Docker services. Instead of re-explaining your architecture every session, each service has a dedicated skill package that Claude loads on demand.
+
+---
+
+## What It Does
+
+**Three workflow skills** form the trinity:
+
+| Skill | Role | When it runs |
+|---|---|---|
+| `creating-service-skills` | Builds new skill packages via 3-phase workflow (scaffold + Serena deep dive + hook registration) | Manually via `/creating-service-skills` |
+| `using-service-skills` | Discovers and activates expert personas | Automatically at session start |
+| `updating-service-skills` | Detects drift when code changes | Automatically on every file write |
+
+**Five hooks** keep everything wired together:
+
+| Hook | Type | Trigger | Effect |
+|---|---|---|---|
+| `SessionStart` | Claude Code | Session opens | Injects lightweight service catalog into context (~150 tokens) |
+| `PreToolUse` | Claude Code | Any Read/Write/Edit/Grep/Glob/Bash | Checks if the operation touches a service territory; injects skill load reminder and enforcement |
+| `PostToolUse` | Claude Code | Any Write/Edit | Checks if modified file belongs to a registered service; notifies Claude to sync docs |
+| `pre-commit` | Git | `git commit` | Warns if source files changed without SSOT documentation update (non-blocking) |
+| `pre-push` | Git | `git push` | Warns if service skills are older than the source files being pushed (non-blocking) |
+
+**Each generated skill package** for a service contains:
+
+```
+.claude/skills/<service-name>/
+├── SKILL.md                  — architecture, data flows, failure modes, common operations
+├── scripts/
+│   ├── health_probe.py       — container status + table freshness check
+│   ├── log_hunter.py         — service-specific log pattern analysis
+│   ├── data_explorer.py      — read-only DB inspection
+│   └── <specialist>.py       — service-type-specific inspector
+└── references/
+    ├── deep_dive.md          — Phase 2 research notes
+    └── architecture_ssot.md  — link to project SSOT if available
+```
+
+---
+
+## Installation
+
+Run once, from inside your target project directory:
+
+```bash
+cd ~/projects/my-project
+python3 /path/to/jaggers-agent-tools/project-skills/service-skills-set/install-service-skills.py
+```
+
+This installs the three workflow skills, wires `settings.json` hooks, and activates git hooks. Idempotent — safe to re-run after updates.
+
+---
+
+## Creating a Service Skill
+
+```bash
+# In Claude Code, invoke the skill:
+/creating-service-skills
+```
+
+The skill runs a **mandatory three-phase workflow**:
+
+### Phase 1 — Automated Skeleton
+
+```bash
+python3 "$CLAUDE_PROJECT_DIR/.claude/skills/creating-service-skills/scripts/scaffolder.py" \
+  create <service-id> <territory-path> "<description>"
+```
+
+Reads `docker-compose*.yml`, `Dockerfile`, and dependency files. Produces:
+- `SKILL.md` with `[PENDING RESEARCH]` markers
+- Script stubs in `scripts/`
+- Official documentation links auto-detected from image tags and package files
+- Entry in `.claude/skills/service-registry.json`
+
+### Phase 2 — Agentic Deep Dive
+
+Claude reads the actual source code to fill every `[PENDING RESEARCH]` marker.
+Uses Serena LSP tools (not raw file reads) for efficiency:
+
+```
+get_symbols_overview   → map module structure
+find_symbol            → read specific functions
+search_for_pattern     → find log strings, SQL queries, env vars
+find_referencing_symbols → trace data flows
+```
+
+### Phase 3 — Hook Registration
+
+After the deep dive is complete, Claude verifies the auto-activation infrastructure:
+
+1. Confirms the `PreToolUse` hook is present in `.claude/settings.json` (pointing to `skill_activator.py`)
+2. Verifies the service entry in `.claude/skills/service-registry.json` has territory globs set
+3. Informs you that the skill will now auto-activate whenever Claude:
+   - Operates on a file matching the service's territory globs
+   - Runs a Bash command that mentions the service name or container name
+
+No manual registration step is needed — the installer wires the hooks at project setup time. Phase 3 is a verification and communication step only.
+
+A skill is **complete** only when:
+- No `[PENDING RESEARCH]` markers remain
+- `health_probe.py` queries real tables with correct stale thresholds
+- `log_hunter.py` patterns sourced from actual codebase error strings
+- Troubleshooting table has ≥5 rows from real failure modes
+- All scripts support `--json` output
+- `PreToolUse` skill activator hook confirmed in `.claude/settings.json`
+- Service territory globs verified in `.claude/skills/service-registry.json`
+- You have been informed: skill auto-activates on territory file access and service-name commands
+
+---
+
+## Using a Service Skill
+
+At session start, Claude receives:
+
+```xml
+<project_service_catalog>
+Available expert personas:
+- db-expert: SQL & schema optimization (Path: .claude/skills/db-expert/SKILL.md)
+- auth-service: JWT authentication expert (Path: .claude/skills/auth-service/SKILL.md)
+</project_service_catalog>
+```
+
+Claude automatically loads the relevant skill when you ask about a covered service. You can also invoke explicitly:
+
+```
+Read .claude/skills/<service-name>/SKILL.md
+```
+
+### Auto-activation
+
+Once a service skill is registered, you don't need to load it manually.
+The `PreToolUse` hook (`skill_activator.py`) fires automatically whenever
+Claude operates on a file in the service's territory or runs a Bash command
+mentioning the service name. It injects:
+
+```
+[Service Skill] You are about to work with the 'auth-service' service territory.
+  Load the expert skill before proceeding: Read .claude/skills/auth-service/SKILL.md
+  Do not use ad-hoc approaches (raw SQL, improvised docker commands) when the
+  skill defines the correct method.
+```
+
+This enforces that Claude uses the skill's defined diagnostic scripts and
+operational procedures rather than improvising — e.g. running `health_probe.py`
+instead of issuing direct `psql` queries, or checking `log_hunter.py` patterns
+before reading raw docker logs.
+
+### Run scripts directly
+
+```bash
+python3 .claude/skills/<service-name>/scripts/health_probe.py
+python3 .claude/skills/<service-name>/scripts/log_hunter.py --errors-only
+python3 .claude/skills/<service-name>/scripts/data_explorer.py --limit 20 --json
+```
+
+---
+
+## Updating a Service Skill
+
+When you modify service source code, the `PostToolUse` hook fires automatically and Claude sees:
+
+```
+[Skill Sync]: Implementation drift detected in 'auth-service'.
+File 'src/auth/jwt.py' was modified.
+Use '/updating-service-skills' to sync the Auth Service documentation.
+```
+
+To sync:
+
+```bash
+/updating-service-skills
+```
+
+To mark a service as synced after manual update:
+
+```bash
+python3 .claude/skills/updating-service-skills/scripts/drift_detector.py sync <service-id>
+```
+
+To scan all services for drift:
+
+```bash
+python3 .claude/skills/updating-service-skills/scripts/drift_detector.py scan
+```
+
+---
+
+## Registry
+
+`.claude/skills/service-registry.json` is the source of truth for registered services:
+
+```json
+{
+  "services": {
+    "auth-service": {
+      "name": "Auth Service",
+      "territory": ["src/auth/**/*.py"],
+      "skill_path": ".claude/skills/auth-service/SKILL.md",
+      "description": "JWT authentication and session management",
+      "last_sync": "2026-02-23T19:00:00Z"
+    }
+  }
+}
+```
+
+The `territory` globs determine which file paths trigger drift detection and skill auto-activation.
+
+---
+
+## Project Structure
+
+```
+project-skills/service-skills-set/      — this repository's source
+├── install-service-skills.py           — installer (run from inside target project)
+└── .claude/
+    ├── settings.json                   — settings template with all 3 hook events
+    ├── git-hooks/
+    │   ├── doc_reminder.py             — pre-commit: SSOT reminder
+    │   └── skill_staleness.py          — pre-push: stale skill warning
+    ├── creating-service-skills/        — workflow skill: build new service skills
+    ├── using-service-skills/           — workflow skill: catalog injection + skill activation
+    └── updating-service-skills/        — workflow skill: drift detection
+
+.claude/                                — installed into your project
+├── settings.json                       — SessionStart + PreToolUse + PostToolUse hooks
+└── skills/
+    ├── service-registry.json
+    ├── creating-service-skills/
+    ├── using-service-skills/
+    ├── updating-service-skills/
+    └── <generated-service-skills>/
+```

package/project-skills/tdd-guard/.claude/settings.json

@@ -0,0 +1,38 @@
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit|MultiEdit|TodoWrite",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "tdd-guard",
+            "timeout": 30
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "tdd-guard --prompt-check",
+            "timeout": 15
+          }
+        ]
+      }
+    ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "tdd-guard --session-init",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}