Merge remote-tracking branch 'origin/sprint-34/client'

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

tooling/generate-star-map-data.py

@@ -7,8 +7,8 @@ Run from any directory — paths are resolved relative to this script's location
 
 Sources:
     docs/design/star-map.json     — graph topology (nodes + edges)
-    server/server/data/systems.db — proper names, geographic sectors
-    wiki/star-systems/            — star type, bodies, population, GTTR excerpt
+    server/data/systems.db        — proper names, geographic sectors, bodies, GDP tier
+    wiki/star-systems/            — star type, GTTR excerpt (bodies/population from systems.db)
 
 Output:
     client/data/star_map_data.json — self-contained client data for the star map UI
@@ -21,16 +21,11 @@ import sqlite3
 import sys
 import tempfile
 
-# Resolve project root from this script's location: tooling/ is one level below root.
+# Resolve project root from this script's location.
 # Works regardless of cwd — no fragile relative path guessing.
 _SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
 _PROJECT_ROOT = os.path.dirname(_SCRIPT_DIR)
 
-# Worktree layout: settled-reach/{client,server,main}/
-# This script lives in client/tooling/, so _PROJECT_ROOT = client/.
-# The parent of _PROJECT_ROOT is the worktree parent where sibling dirs live.
-_WORKTREE_PARENT = os.path.dirname(_PROJECT_ROOT)
-
 STAR_MAP_PATH = os.path.join(_PROJECT_ROOT, "docs", "design", "star-map.json")
 SYSTEMS_DB_PATH = os.path.join(_PROJECT_ROOT, "server", "data", "systems.db")
 WIKI_PATH = os.path.join(_PROJECT_ROOT, "wiki", "star-systems")
@@ -43,13 +38,14 @@ def system_id_to_wiki_slug(system_id: str) -> str:
 
 
 def parse_wiki_index(system_id: str) -> dict:
-    """Extract star type, bodies summary, and population from index.md.
+    """Extract star type from index.md.
 
-    Returns dict with keys: star_type, bodies, population (all strings, may be empty).
+    Bodies and population are authoritative from systems.db — not read from wiki.
+    Returns dict with key: star_type (string, may be empty).
     """
     slug = system_id_to_wiki_slug(system_id)
     path = os.path.join(WIKI_PATH, slug, "index.md")
-    result = {"star_type": "", "bodies": "", "population": ""}
+    result = {"star_type": ""}
     if not os.path.exists(path):
         return result
     with open(path, encoding="utf-8") as f:
@@ -60,18 +56,7 @@ def parse_wiki_index(system_id: str) -> dict:
     if m:
         raw = m.group(1).strip()
         # Extract spectral class — everything before " ·" or end of string
-        star_type = raw.split("·")[0].strip()
-        result["star_type"] = star_type
-
-    # Bodies row: | **Bodies** | 2 habitable · 3 inhabited |
-    m = re.search(r"\|\s*\*\*Bodies\*\*\s*\|\s*([^|]+?)\s*\|", content)
-    if m:
-        result["bodies"] = m.group(1).strip()
-
-    # Population row: | **Population** | 1,200,000,000 |
-    m = re.search(r"\|\s*\*\*Population\*\*\s*\|\s*([^|]+?)\s*\|", content)
-    if m:
-        result["population"] = m.group(1).strip()
+        result["star_type"] = raw.split("·")[0].strip()
 
     return result
 
@@ -106,6 +91,45 @@ def parse_gttr_excerpt(system_id: str) -> str:
     return " ".join(paragraph_lines)
 
 
+GDP_PER_CAPITA: dict = {
+    5: 75_000,
+    4: 40_000,
+    3: 15_000,
+    2: 5_000,
+    1: 2_000,
+    0: 500,
+}
+
+
+def infer_tier_from_population(pop: int) -> int:
+    """Infer an economic tier from total population when no explicit tier is set."""
+    if pop >= 5_000_000_000:
+        return 5
+    if pop >= 1_000_000_000:
+        return 4
+    if pop >= 200_000_000:
+        return 3
+    if pop >= 10_000_000:
+        return 2
+    return 1
+
+
+def compute_gdp(total_pop: int, economic_tier: int | None) -> str:
+    """Return a formatted GDP string in Tractus, or empty string if no population."""
+    if total_pop == 0:
+        return ""
+    tier = economic_tier if economic_tier is not None else infer_tier_from_population(total_pop)
+    per_cap = GDP_PER_CAPITA.get(tier, GDP_PER_CAPITA[1])
+    value = total_pop * per_cap
+    if value < 1_000_000_000:
+        return f"{value / 1_000_000:.1f} MTr"
+    if value < 1_000_000_000_000:
+        return f"{value / 1_000_000_000:.1f} BTr"
+    if value < 1_000_000_000_000_000:
+        return f"{value / 1_000_000_000_000:.1f} TTr"
+    return f"{value / 1_000_000_000_000_000:.1f} QTr"
+
+
 def build_adjacency(edges: list) -> dict:
     """Build a map from system_id to list of adjacent system_ids from edges."""
     adj: dict = {}
@@ -134,35 +158,45 @@ def generate() -> dict:
     with open(STAR_MAP_PATH) as f:
         star_map = json.load(f)
 
-    conn = sqlite3.connect(SYSTEMS_DB_PATH)
-    conn.row_factory = sqlite3.Row
-    cur = conn.cursor()
-    cur.execute(
-        "SELECT system_id, proper_name, geographic_sector, geographic_band "
-        "FROM star_systems"
-    )
-    db_lookup = {row["system_id"]: dict(row) for row in cur.fetchall()}
+    try:
+        conn = sqlite3.connect(SYSTEMS_DB_PATH)
+        conn.row_factory = sqlite3.Row
+        cur = conn.cursor()
 
-    # Aggregate body data per system from the bodies table
-    cur.execute("""
-        SELECT system_id,
-            SUM(CASE WHEN atmosphere IN ('breathable','standard') AND body_type IN ('planet','moon') THEN 1 ELSE 0 END) AS habitable,
-            SUM(CASE WHEN inhabited = 1 THEN 1 ELSE 0 END) AS inhabited,
-            SUM(CASE WHEN inhabited = 1 THEN COALESCE(population, 0) ELSE 0 END) AS total_pop
-        FROM bodies
-        GROUP BY system_id
-    """)
-    body_stats = {row["system_id"]: dict(row) for row in cur.fetchall()}
+        cur.execute(
+            "SELECT system_id, proper_name, geographic_sector, geographic_band "
+            "FROM star_systems"
+        )
+        db_lookup = {row["system_id"]: dict(row) for row in cur.fetchall()}
 
-    # Also sum station populations
-    cur.execute("""
-        SELECT system_id,
-            SUM(COALESCE(population, 0)) AS station_pop
-        FROM stations
-        GROUP BY system_id
-    """)
-    station_stats = {row["system_id"]: dict(row) for row in cur.fetchall()}
-    conn.close()
+        # Aggregate body data per system from the bodies table
+        cur.execute("""
+            SELECT system_id,
+                SUM(CASE WHEN atmosphere IN ('breathable','standard') AND body_type IN ('planet','moon') THEN 1 ELSE 0 END) AS habitable,
+                SUM(CASE WHEN inhabited = 1 THEN 1 ELSE 0 END) AS inhabited,
+                SUM(CASE WHEN inhabited = 1 THEN COALESCE(population, 0) ELSE 0 END) AS total_pop
+            FROM bodies
+            GROUP BY system_id
+        """)
+        body_stats = {row["system_id"]: dict(row) for row in cur.fetchall()}
+
+        # Also sum station populations
+        cur.execute("""
+            SELECT system_id,
+                SUM(COALESCE(population, 0)) AS station_pop
+            FROM stations
+            GROUP BY system_id
+        """)
+        station_stats = {row["system_id"]: dict(row) for row in cur.fetchall()}
+
+        # Economic tier for GDP calculation
+        cur.execute("SELECT system_id, economic_tier FROM system_economy")
+        econ_tiers = {row["system_id"]: row["economic_tier"] for row in cur.fetchall()}
+    except sqlite3.Error as e:
+        print(f"ERROR: systems.db query failed: {e}", file=sys.stderr)
+        sys.exit(1)
+    finally:
+        conn.close()
 
     adjacency = build_adjacency(star_map["edges"])
 
@@ -204,6 +238,9 @@ def generate() -> dict:
 
         entry["bodies"] = "%d habitable · %d inhabited" % (hab, inh)
         entry["population"] = "{:,}".format(total_pop)
+        gdp_str = compute_gdp(total_pop, econ_tiers.get(sid))
+        if gdp_str:
+            entry["gdp"] = gdp_str
         if gttr:
             entry["gttr_excerpt"] = gttr
         if n.get("is_gateway"):