attocode-code-intel 0.1.0__py3-none-any.whl

attocode_intel/api/routes/webhooks.py

@@ -0,0 +1,313 @@
+"""Webhook endpoints for GitHub/GitLab/Bitbucket push events (service mode only)."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import json
+import logging
+import uuid
+from typing import TYPE_CHECKING
+
+from fastapi import APIRouter, Depends, Header, HTTPException, Request
+from pydantic import BaseModel
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from attocode_intel.api.deps import get_db_session
+from attocode_intel.db.models import Repository, WebhookConfig
+
+if TYPE_CHECKING:
+    from cryptography.fernet import Fernet
+
+router = APIRouter(prefix="/api/v1/webhooks", tags=["webhooks"])
+logger = logging.getLogger(__name__)
+
+
+def _get_fernet() -> Fernet:
+    """Get Fernet instance using SECRET_KEY from config."""
+    from attocode_intel.crypto import _get_fernet as _shared_get_fernet
+
+    return _shared_get_fernet()
+
+
+def _encrypt_secret(secret: str) -> str:
+    """Encrypt a webhook secret for storage."""
+    return _get_fernet().encrypt(secret.encode()).decode()
+
+
+def _decrypt_secret(encrypted: str) -> str:
+    """Decrypt a stored webhook secret."""
+    return _get_fernet().decrypt(encrypted.encode()).decode()
+
+
+class WebhookConfigRequest(BaseModel):
+    repo_id: str
+    provider: str  # github|gitlab|bitbucket
+    secret: str
+    events: list[str] = ["push"]
+
+
+class WebhookConfigResponse(BaseModel):
+    id: str
+    repo_id: str
+    provider: str
+    events: list[str]
+    active: bool
+
+
+@router.post("/config", response_model=WebhookConfigResponse)
+async def create_webhook_config(
+    req: WebhookConfigRequest,
+    session: AsyncSession = Depends(get_db_session),
+) -> WebhookConfigResponse:
+    """Create a webhook configuration for a repository."""
+    repo_result = await session.execute(
+        select(Repository).where(Repository.id == uuid.UUID(req.repo_id))
+    )
+    repo = repo_result.scalar_one_or_none()
+    if repo is None:
+        raise HTTPException(status_code=404, detail="Repository not found")
+
+    secret_hash = hashlib.sha256(req.secret.encode()).hexdigest()
+    secret_encrypted = _encrypt_secret(req.secret)
+    config = WebhookConfig(
+        repo_id=repo.id,
+        provider=req.provider,
+        secret_hash=secret_hash,
+        secret_encrypted=secret_encrypted,
+        events=req.events,
+    )
+    session.add(config)
+    await session.commit()
+    await session.refresh(config)
+
+    return WebhookConfigResponse(
+        id=str(config.id),
+        repo_id=str(config.repo_id),
+        provider=config.provider,
+        events=list(config.events),
+        active=config.active,
+    )
+
+
+@router.post("/github")
+async def github_webhook(
+    request: Request,
+    x_hub_signature_256: str | None = Header(None),
+    x_github_event: str | None = Header(None),
+    session: AsyncSession = Depends(get_db_session),
+) -> dict:
+    """Handle GitHub webhook events."""
+    body = await request.body()
+
+    # Parse payload
+    try:
+        payload = json.loads(body)
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON payload")
+
+    # Identify repository
+    repo_url = payload.get("repository", {}).get("clone_url", "")
+    if not repo_url:
+        repo_url = payload.get("repository", {}).get("html_url", "")
+
+    if not repo_url:
+        raise HTTPException(status_code=400, detail="Cannot identify repository from payload")
+
+    # Find matching webhook config
+    result = await session.execute(
+        select(WebhookConfig).where(
+            WebhookConfig.provider == "github",
+            WebhookConfig.active == True,  # noqa: E712
+        )
+    )
+    webhook = None
+    for wh in result.scalars():
+        # Verify the repo matches
+        repo_result = await session.execute(
+            select(Repository).where(Repository.id == wh.repo_id)
+        )
+        repo = repo_result.scalar_one_or_none()
+        if repo and repo.clone_url and repo_url in (repo.clone_url, repo.clone_url.rstrip(".git")):
+            webhook = wh
+            break
+
+    if webhook is None:
+        raise HTTPException(status_code=404, detail="No matching webhook config found")
+
+    # Verify signature using decrypted secret
+    if x_hub_signature_256:
+        if webhook.secret_encrypted:
+            secret = _decrypt_secret(webhook.secret_encrypted)
+            _verify_github_signature(body, x_hub_signature_256, secret)
+        else:
+            # Legacy fallback: no encrypted secret stored yet (pre-migration data)
+            logger.warning("Webhook %s has no encrypted secret; signature verification skipped", webhook.id)
+
+    # Log webhook received
+    from attocode_intel.audit import log_event
+
+    repo_result2 = await session.execute(
+        select(Repository).where(Repository.id == webhook.repo_id)
+    )
+    wh_repo = repo_result2.scalar_one_or_none()
+    if wh_repo:
+        await log_event(session, wh_repo.org_id, "webhook.received", repo_id=webhook.repo_id, detail={"provider": "github", "event": x_github_event or "push"})
+        await session.commit()
+
+    # Handle events
+    event = x_github_event or "push"
+    if event == "push":
+        ref = payload.get("ref", "")
+        branch = ref.removeprefix("refs/heads/")
+        before = payload.get("before", "")
+        after = payload.get("after", "")
+
+        logger.info("GitHub push: %s %s → %s", branch, before[:8], after[:8])
+
+        # Enqueue delta index job
+        try:
+            from arq import create_pool
+
+            from attocode_intel.workers.settings import get_redis_settings
+
+            pool = await create_pool(get_redis_settings())
+            await pool.enqueue_job(
+                "index_branch_delta",
+                str(webhook.repo_id),
+                branch,
+                before,
+                after,
+            )
+            await pool.aclose()
+            return {"status": "queued", "branch": branch, "job": "index_branch_delta"}
+        except Exception as e:
+            logger.warning("Failed to enqueue job: %s", e)
+            return {"status": "received", "branch": branch, "note": "Job queuing unavailable"}
+
+    elif event == "pull_request":
+        action = payload.get("action", "")
+        pr = payload.get("pull_request", {})
+        merged = pr.get("merged", False)
+
+        if action == "closed" and merged:
+            # Auto-trigger merge + delete source branch in DB
+            base_branch = pr.get("base", {}).get("ref", "")
+            head_branch = pr.get("head", {}).get("ref", "")
+
+            if base_branch and head_branch:
+                logger.info("GitHub PR merged: %s → %s", head_branch, base_branch)
+                try:
+                    from attocode_intel.db.models import Branch
+                    from attocode_intel.storage.branch_overlay import BranchOverlay
+
+                    repo_result3 = await session.execute(
+                        select(Repository).where(Repository.id == webhook.repo_id)
+                    )
+                    merge_repo = repo_result3.scalar_one_or_none()
+                    if merge_repo:
+                        src_result = await session.execute(
+                            select(Branch).where(
+                                Branch.repo_id == merge_repo.id, Branch.name == head_branch
+                            )
+                        )
+                        tgt_result = await session.execute(
+                            select(Branch).where(
+                                Branch.repo_id == merge_repo.id, Branch.name == base_branch
+                            )
+                        )
+                        src_branch = src_result.scalar_one_or_none()
+                        tgt_branch = tgt_result.scalar_one_or_none()
+
+                        if src_branch and tgt_branch:
+                            overlay = BranchOverlay(session)
+                            await overlay.merge_branch(
+                                src_branch.id, tgt_branch.id, delete_source=True,
+                            )
+                            await session.commit()
+                            return {
+                                "status": "merged",
+                                "source": head_branch,
+                                "target": base_branch,
+                            }
+                except Exception as e:
+                    logger.warning("Auto-merge failed for PR: %s", e)
+
+        return {"status": "received", "event": "pull_request", "action": action}
+
+    return {"status": "ignored", "event": event}
+
+
+@router.post("/gitlab")
+async def gitlab_webhook(
+    request: Request,
+    x_gitlab_token: str | None = Header(None),
+    session: AsyncSession = Depends(get_db_session),
+) -> dict:
+    """Handle GitLab webhook events."""
+    body = await request.body()
+    payload = json.loads(body)
+
+    # GitLab uses a shared secret token
+    if not x_gitlab_token:
+        raise HTTPException(status_code=401, detail="X-Gitlab-Token header required")
+
+    token_hash = hashlib.sha256(x_gitlab_token.encode()).hexdigest()
+    result = await session.execute(
+        select(WebhookConfig).where(
+            WebhookConfig.provider == "gitlab",
+            WebhookConfig.secret_hash == token_hash,
+            WebhookConfig.active == True,  # noqa: E712
+        )
+    )
+    webhook = result.scalar_one_or_none()
+    if webhook is None:
+        raise HTTPException(status_code=401, detail="Invalid token")
+
+    event_type = payload.get("object_kind", "push")
+    if event_type == "push":
+        ref = payload.get("ref", "")
+        branch = ref.removeprefix("refs/heads/")
+        before = payload.get("before", "")
+        after = payload.get("after", "")
+
+        logger.info("GitLab push: %s %s → %s", branch, before[:8], after[:8])
+        return {"status": "received", "branch": branch}
+
+    return {"status": "ignored", "event": event_type}
+
+
+@router.post("/bitbucket")
+async def bitbucket_webhook(
+    request: Request,
+    session: AsyncSession = Depends(get_db_session),
+) -> dict:
+    """Handle Bitbucket webhook events (Cloud)."""
+    body = await request.body()
+    payload = json.loads(body)
+
+    # Bitbucket Cloud uses a shared UUID key in the URL or body
+    event = request.headers.get("x-event-key", "repo:push")
+
+    if event == "repo:push":
+        changes = payload.get("push", {}).get("changes", [])
+        for change in changes:
+            new = change.get("new", {})
+            branch = new.get("name", "")
+            commit = new.get("target", {}).get("hash", "")
+            logger.info("Bitbucket push: %s → %s", branch, commit[:8])
+
+        return {"status": "received", "changes": len(changes)}
+
+    return {"status": "ignored", "event": event}
+
+
+def _verify_github_signature(body: bytes, signature_header: str, secret: str) -> None:
+    """Verify GitHub webhook HMAC-SHA256 signature."""
+    if not signature_header.startswith("sha256="):
+        raise HTTPException(status_code=401, detail="Invalid signature format")
+
+    expected = hmac.new(secret.encode(), body, hashlib.sha256).hexdigest()
+    if not hmac.compare_digest(f"sha256={expected}", signature_header):
+        raise HTTPException(status_code=401, detail="Invalid signature")

attocode_intel/api/routes/websocket.py

@@ -0,0 +1,116 @@
+"""WebSocket endpoints for real-time event streaming + presence (service mode only)."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import uuid
+
+from fastapi import APIRouter, Query, WebSocket, WebSocketDisconnect
+
+router = APIRouter(tags=["websocket"])
+logger = logging.getLogger(__name__)
+
+
+@router.websocket("/ws/repos/{repo_id}/events")
+async def repo_events(
+    websocket: WebSocket,
+    repo_id: uuid.UUID,
+    token: str = Query(""),
+    last_event_id: str = Query("$", alias="last_event_id"),
+) -> None:
+    """Stream real-time events for a repository with bidirectional presence support.
+
+    Authenticate via query parameter `token` (JWT).
+    Pass `last_event_id` to replay missed events (e.g. after reconnect).
+    Use "$" for new events only, or "0" to replay all available events.
+
+    Outgoing events: index.started, index.progress, index.completed, index.failed,
+                     presence.joined, presence.left, presence.file_changed.
+
+    Incoming messages:
+        {"type": "presence.update", "file": "src/main.py"}
+        {"type": "presence.heartbeat"}
+    """
+    # Validate auth
+    user_id = ""
+    user_name = ""
+    if token:
+        from attocode_intel.api.auth.jwt import decode_token
+
+        payload = decode_token(token)
+        if payload is None:
+            await websocket.close(code=4001, reason="Invalid token")
+            return
+        user_id = payload.get("sub", "")
+        user_name = payload.get("name", user_id)
+    else:
+        # Allow unauthenticated in development
+        from attocode_intel.api.deps import get_config
+
+        config = get_config()
+        if config.api_key or config.is_service_mode:
+            await websocket.close(code=4001, reason="Token required")
+            return
+
+    await websocket.accept()
+    session_id = str(uuid.uuid4())
+    repo_id_str = str(repo_id)
+    logger.info("WebSocket connected for repo %s (user=%s)", repo_id, user_id)
+
+    async def _pubsub_reader() -> None:
+        """Read events from Redis pubsub and forward to WebSocket."""
+        from attocode_intel.pubsub import subscribe
+
+        async for event in subscribe(repo_id_str, last_event_id=last_event_id):
+            await websocket.send_json(event)
+
+    async def _ws_reader() -> None:
+        """Read incoming messages from WebSocket for presence updates."""
+        while True:
+            try:
+                data = await websocket.receive_json()
+            except (WebSocketDisconnect, RuntimeError):
+                break
+
+            msg_type = data.get("type", "")
+            if msg_type == "presence.update":
+                file_path = data.get("file", "")
+                if user_id:
+                    from attocode_intel.presence import set_presence
+
+                    await set_presence(
+                        repo_id_str, user_id, user_name, file_path, session_id,
+                    )
+            elif msg_type == "presence.heartbeat":
+                if user_id:
+                    from attocode_intel.presence import heartbeat
+
+                    await heartbeat(repo_id_str, user_id, session_id)
+
+    try:
+        # Run both tasks concurrently
+        pubsub_task = asyncio.create_task(_pubsub_reader())
+        ws_task = asyncio.create_task(_ws_reader())
+        done, pending = await asyncio.wait(
+            [pubsub_task, ws_task], return_when=asyncio.FIRST_COMPLETED,
+        )
+        for task in pending:
+            task.cancel()
+    except WebSocketDisconnect:
+        logger.info("WebSocket disconnected for repo %s", repo_id)
+    except Exception as e:
+        logger.warning("WebSocket error for repo %s: %s", repo_id, e)
+        try:
+            await websocket.close(code=1011, reason="Internal error")
+        except Exception:
+            pass
+    finally:
+        # Clean up presence on disconnect
+        if user_id:
+            try:
+                from attocode_intel.presence import remove_presence
+
+                await remove_presence(repo_id_str, user_id, session_id)
+            except Exception:
+                logger.debug("Failed to remove presence on disconnect", exc_info=True)

attocode_intel/api/static/graph.html

@@ -0,0 +1,239 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Code Intelligence — Dependency Graph</title>
+<script src="https://d3js.org/d3.v7.min.js"></script>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:system-ui,-apple-system,sans-serif;background:#0d1117;color:#c9d1d9;overflow:hidden}
+#controls{position:fixed;top:12px;left:12px;z-index:10;display:flex;gap:8px;align-items:center;
+  background:#161b22;border:1px solid #30363d;border-radius:8px;padding:8px 12px;font-size:13px}
+#controls label{color:#8b949e}
+#controls input[type=range]{width:80px}
+#controls input[type=text]{background:#0d1117;border:1px solid #30363d;color:#c9d1d9;
+  border-radius:4px;padding:2px 8px;width:160px;font-size:13px}
+#controls button{background:#238636;color:#fff;border:none;border-radius:4px;padding:4px 10px;
+  cursor:pointer;font-size:12px}
+#controls button:hover{background:#2ea043}
+#controls button.secondary{background:#30363d}
+#controls button.secondary:hover{background:#484f58}
+#info{position:fixed;bottom:12px;left:12px;z-index:10;background:#161b22;border:1px solid #30363d;
+  border-radius:8px;padding:8px 12px;font-size:12px;color:#8b949e;max-width:300px}
+#tooltip{position:fixed;pointer-events:none;z-index:20;background:#1c2128;border:1px solid #30363d;
+  border-radius:6px;padding:8px 12px;font-size:12px;display:none;color:#c9d1d9;
+  box-shadow:0 4px 12px rgba(0,0,0,.4)}
+#tooltip .tt-path{font-weight:bold;margin-bottom:4px}
+#tooltip .tt-line{color:#8b949e}
+svg{display:block;width:100vw;height:100vh}
+.link{stroke-opacity:.4}
+.link:hover{stroke-opacity:.8}
+.node-circle{stroke-width:1.5;cursor:pointer}
+.node-label{font-size:10px;fill:#8b949e;pointer-events:none;text-anchor:middle}
+</style>
+</head>
+<body>
+<div id="controls">
+  <label>Depth</label>
+  <input type="range" id="depthSlider" min="1" max="6" value="3">
+  <span id="depthVal">3</span>
+  <label>Max</label>
+  <input type="range" id="maxSlider" min="20" max="300" value="100" step="10">
+  <span id="maxVal">100</span>
+  <input type="text" id="searchBox" placeholder="Search files...">
+  <button id="goBtn">Reload</button>
+  <button id="resetBtn" class="secondary">Reset</button>
+</div>
+<div id="info">Loading graph data...</div>
+<div id="tooltip">
+  <div class="tt-path"></div>
+  <div class="tt-line tt-lang"></div>
+  <div class="tt-line tt-lines"></div>
+  <div class="tt-line tt-imp"></div>
+  <div class="tt-line tt-comm"></div>
+</div>
+<svg></svg>
+
+<script>
+const LANG_COLORS = {
+  python:'#3572A5',typescript:'#3178c6',javascript:'#f1e05a',go:'#00ADD8',
+  rust:'#dea584',java:'#b07219',c:'#555555',cpp:'#f34b7d',ruby:'#701516',
+  swift:'#F05138',kotlin:'#A97BFF',html:'#e34c26',css:'#563d7c',
+  shell:'#89e051',yaml:'#cb171e',json:'#292929',markdown:'#083fa1',
+};
+const COMMUNITY_COLORS = d3.schemeTableau10;
+
+let projectId = 'default';
+let currentRoot = '';
+let simulation, svg, g, linkG, nodeG, labelG;
+let width = window.innerWidth, height = window.innerHeight;
+
+function init() {
+  svg = d3.select('svg').attr('width', width).attr('height', height);
+
+  svg.append('defs').append('marker')
+    .attr('id','arrow').attr('viewBox','0 -4 8 8').attr('refX',18)
+    .attr('markerWidth',6).attr('markerHeight',6).attr('orient','auto')
+    .append('path').attr('d','M0,-4L8,0L0,4').attr('fill','#484f58');
+
+  g = svg.append('g');
+  linkG = g.append('g').attr('class','links');
+  nodeG = g.append('g').attr('class','nodes');
+  labelG = g.append('g').attr('class','labels');
+
+  const zoom = d3.zoom().scaleExtent([0.1, 8])
+    .on('zoom', e => g.attr('transform', e.transform));
+  svg.call(zoom);
+
+  const depthSlider = document.getElementById('depthSlider');
+  const maxSlider = document.getElementById('maxSlider');
+  const depthVal = document.getElementById('depthVal');
+  const maxVal = document.getElementById('maxVal');
+  depthSlider.oninput = () => { depthVal.textContent = depthSlider.value; };
+  maxSlider.oninput = () => { maxVal.textContent = maxSlider.value; };
+  document.getElementById('goBtn').onclick = () => fetchAndRender();
+  document.getElementById('resetBtn').onclick = () => {
+    currentRoot = '';
+    document.getElementById('searchBox').value = '';
+    fetchAndRender();
+  };
+  document.getElementById('searchBox').addEventListener('keydown', e => {
+    if (e.key === 'Enter') fetchAndRender();
+  });
+
+  fetchAndRender();
+}
+
+async function fetchAndRender() {
+  const depth = document.getElementById('depthSlider').value;
+  const maxNodes = document.getElementById('maxSlider').value;
+  const search = document.getElementById('searchBox').value.trim();
+
+  let root = currentRoot;
+  if (search) root = search;
+
+  const params = new URLSearchParams({ depth, max_nodes: maxNodes });
+  if (root) params.set('root', root);
+
+  const info = document.getElementById('info');
+  info.textContent = 'Loading...';
+
+  try {
+    const resp = await fetch('/api/v2/projects/' + encodeURIComponent(projectId) + '/graph-viz?' + params);
+    if (!resp.ok) throw new Error('HTTP ' + resp.status);
+    const data = await resp.json();
+    info.textContent = data.nodes.length + ' nodes, ' + data.links.length + ' edges' +
+      (data.communities.length ? ', ' + data.communities.length + ' communities' : '');
+    render(data);
+  } catch (err) {
+    info.textContent = 'Error: ' + err.message;
+  }
+}
+
+function render(data) {
+  const { nodes, links, communities } = data;
+  if (!nodes.length) return;
+
+  const commIds = [...new Set(nodes.map(n => n.group))].filter(g => g >= 0).sort();
+  const commColor = id => id < 0 ? '#484f58' : COMMUNITY_COLORS[commIds.indexOf(id) % COMMUNITY_COLORS.length];
+
+  const maxImp = d3.max(nodes, d => d.importance) || 1;
+  const r = d => 4 + 12 * (d.importance / maxImp);
+
+  const color = d => {
+    if (d.language && LANG_COLORS[d.language]) return LANG_COLORS[d.language];
+    return commColor(d.group);
+  };
+
+  if (simulation) simulation.stop();
+
+  linkG.selectAll('*').remove();
+  const linkSel = linkG.selectAll('line').data(links).enter().append('line')
+    .attr('class', 'link')
+    .attr('stroke', '#30363d')
+    .attr('stroke-width', 1)
+    .attr('marker-end', 'url(#arrow)');
+
+  nodeG.selectAll('*').remove();
+  const nodeSel = nodeG.selectAll('circle').data(nodes, d => d.id).enter().append('circle')
+    .attr('class', 'node-circle')
+    .attr('r', r)
+    .attr('fill', color)
+    .attr('stroke', d => d3.color(color(d)).brighter(0.8))
+    .call(drag());
+
+  labelG.selectAll('*').remove();
+  const labelSel = labelG.selectAll('text').data(nodes, d => d.id).enter().append('text')
+    .attr('class', 'node-label')
+    .attr('dy', d => r(d) + 12)
+    .text(d => {
+      const parts = d.id.split('/');
+      return parts[parts.length - 1];
+    });
+
+  // Tooltip via textContent (safe DOM updates)
+  const tooltip = document.getElementById('tooltip');
+  const ttPath = tooltip.querySelector('.tt-path');
+  const ttLang = tooltip.querySelector('.tt-lang');
+  const ttLines = tooltip.querySelector('.tt-lines');
+  const ttImp = tooltip.querySelector('.tt-imp');
+  const ttComm = tooltip.querySelector('.tt-comm');
+
+  nodeSel
+    .on('mouseover', (e, d) => {
+      tooltip.style.display = 'block';
+      ttPath.textContent = d.id;
+      ttLang.textContent = 'Language: ' + (d.language || '(unknown)');
+      ttLines.textContent = 'Lines: ' + d.lines;
+      ttImp.textContent = 'Importance: ' + d.importance;
+      ttComm.textContent = 'Community: ' + (d.group >= 0 ? d.group : 'none');
+    })
+    .on('mousemove', e => {
+      tooltip.style.left = (e.clientX + 12) + 'px';
+      tooltip.style.top = (e.clientY - 10) + 'px';
+    })
+    .on('mouseout', () => { tooltip.style.display = 'none'; })
+    .on('click', (e, d) => {
+      currentRoot = d.id;
+      document.getElementById('searchBox').value = d.id;
+      fetchAndRender();
+    });
+
+  simulation = d3.forceSimulation(nodes)
+    .force('link', d3.forceLink(links).id(d => d.id).distance(60))
+    .force('charge', d3.forceManyBody().strength(-120))
+    .force('center', d3.forceCenter(width / 2, height / 2))
+    .force('collision', d3.forceCollide().radius(d => r(d) + 2))
+    .on('tick', () => {
+      linkSel
+        .attr('x1', d => d.source.x).attr('y1', d => d.source.y)
+        .attr('x2', d => d.target.x).attr('y2', d => d.target.y);
+      nodeSel.attr('cx', d => d.x).attr('cy', d => d.y);
+      labelSel.attr('x', d => d.x).attr('y', d => d.y);
+    });
+}
+
+function drag() {
+  return d3.drag()
+    .on('start', (e, d) => {
+      if (!e.active) simulation.alphaTarget(0.3).restart();
+      d.fx = d.x; d.fy = d.y;
+    })
+    .on('drag', (e, d) => { d.fx = e.x; d.fy = e.y; })
+    .on('end', (e, d) => {
+      if (!e.active) simulation.alphaTarget(0);
+      d.fx = null; d.fy = null;
+    });
+}
+
+window.addEventListener('resize', () => {
+  width = window.innerWidth; height = window.innerHeight;
+  svg.attr('width', width).attr('height', height);
+  if (simulation) simulation.force('center', d3.forceCenter(width / 2, height / 2)).alpha(0.3).restart();
+});
+
+init();
+</script>
+</body>
+</html>