@adgine/geo-cli 1.2.8

package/skills/adgine-geo-billing/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: adgine/geo-billing
+description: Queries GEO platform subscription and credits information — lists subscription plans, reports active subscription status, and queries detailed credits balance (subscription pool + purchased pool). Use when the user asks about pricing, plans, subscription status, billing, renewal, credits, balance, 套餐, 订阅, 价格, 续费, 余额, 积分, 充值, 支付, 查询积分, 我的积分, credits balance, 我用的什么套餐, 还剩多少积分, 购买积分. Read-only — does not perform purchases or plan changes (that requires the web UI).
+---
+
+# GEO Billing
+
+Read-only access to subscription and credits state. Use this skill when the user asks
+"what plan am I on?" / "how much does X cost?" / "when does my subscription
+renew?" / "how many credits do I have left?" / "查询积分" / "我还有多少积分" /
+"积分余额" / "充值了多少".
+
+For purchases or plan changes, direct the user to the web checkout flow on the
+GEO platform — those operations are not covered by this skill.
+
+## Output rules — IDs (apply to every reply)
+
+These rules apply to **every list, table, and confirmation message** in this skill. Their goal: keep user-facing output friendly while preserving the IDs the agent needs internally.
+
+1. **Lists & tables — never show raw UUIDs in cells.** Use a 1-based `#` index column instead. Keep a private mental mapping of `#N → actual UUID` so that follow-up commands like *"delete #3"*, *"run citation test on #1 #2"*, *"show details of the 2nd one"* resolve to the right entity.
+   - Index numbers restart from 1 in each new list — they are not stable across calls.
+   - If the user references *"the topic about X"* / *"that Poki vs CrazyGames prompt"*, match by visible content (name / title / domain / prompt text), not by ID.
+
+2. **Single-item operations — prefer a human name over an ID.**
+   - ✅ *"Project **Poki vs Competitors** deleted."*
+   - ✅ *"Topic **Brand mentions in 2024** updated — name → 'Brand mentions 2025'."*
+   - ❌ *"Project `a4305b57-1c79-4cec-a17c-16eb1d959ea6` deleted."*
+   - If the entity has **no human-readable name** (e.g. an anonymous prompt or a job), use a short 8-character prefix: *"Prompt `2a2a8f4f…` deleted."* Never paste the full UUID.
+
+3. **Always exception: `--json` mode.** When the user passes `--json` to a script or explicitly asks for raw JSON / debug output, print the script output verbatim — do not strip IDs.
+
+4. **Internally, the agent still uses full UUIDs** for every API call (`--project-id`, `--topic-id`, `--prompt-id`, etc.). The display rules only affect what is shown back to the user.
+
+---
+
+## Step 1: Make sure GEO_API_KEY is configured
+
+Scripts auto-load `GEO_API_KEY` from `<skills-root>/.env` on import — **no `export` needed, no shell restart needed**. To check the configuration, run any script (it prints the exact `.env` path if the key is missing).
+
+- ✅ Key already in `<skills-root>/.env` → proceed.
+- ❌ Key missing, or user just gave you a new key → go to the **adgine-geo-projects** skill, **Step 0**, which runs `python3 <skills-root>/setup.py <KEY>` to write the key into the correct `.env` file. **Never** write the key to `~/.zshrc`, `~/.bashrc`, Hermes global config, or any user-secrets store.
+
+> ⚠️ **IMPORTANT:** In all shell/exec commands, always reference the key as `$GEO_API_KEY` (the environment variable). Never hardcode the literal value.
+
+## Scripts
+
+### List all subscription plans
+
+```bash
+python3 scripts/list_plans.py [--json]
+```
+
+### Get the current user's subscription
+
+```bash
+python3 scripts/get_subscription.py [--json]
+```
+
+### Get the current user's credits balance
+
+```bash
+python3 scripts/get_credits.py [--json]
+```
+
+Returns detailed credits breakdown: subscription pool (monthly allocation) vs
+purchased pool (top-ups). Use this when the user asks about credits, 积分, 余额,
+balance, or "how many credits do I have".
+
+### Get credits pricing information
+
+```bash
+python3 scripts/get_credits_pricing.py [--json]
+```
+
+Returns unit price, min/max purchase limits, and preset options. Use when the
+user asks "how much do credits cost?" / "积分多少钱" / "充值价格".
+
+## Output Format
+
+> **Table cell rule:** ASCII only inside fenced tables. Emoji allowed only on
+> labels above the fence. Status vocabulary: `Active` / `Trialing` /
+> `Cancelled` / `Past_due` etc. Change values: `+N` / `-N` / `--` / `0`.
+
+### Recommended layout
+
+> 💳 **Current Subscription**
+
+```
+┌────────────────────┬──────────────────────────────┐
+│ Field              │ Value                        │
+├────────────────────┼──────────────────────────────┤
+│ Plan               │ Pro                          │
+│ Status             │ Active                       │
+│ Renews             │ 2025-12-01                   │
+│ Credits Remaining  │ 4,210 / 10,000               │
+└────────────────────┴──────────────────────────────┘
+```
+
+> 💰 **Available Plans**
+
+```
+┌────────────────────┬──────────┬──────────┬──────────────────────────┐
+│ Plan               │    Price │ Interval │ Notes                    │
+├────────────────────┼──────────┼──────────┼──────────────────────────┤
+│ Free               │        0 │ month    │ Starter tier             │
+│ Pro                │   49 USD │ month    │ 10,000 credits           │
+│ Enterprise         │  Custom  │ month    │ Contact sales            │
+└────────────────────┴──────────┴──────────┴──────────────────────────┘
+```
+
+## Related endpoints
+
+| Method | Path | Description |
+|---|---|---|
+| GET | `/api/payments/plans` | 所有套餐列表 |
+| GET | `/api/payments/subscription` | 当前订阅状态 |
+| GET | `/api/payments/credits/me` | 积分余额（订阅池+购买池） |
+| GET | `/api/payments/credits/pricing` | 积分购买定价信息 |

package/skills/adgine-geo-billing/scripts/_client.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+"""Shared HTTP client utilities for geo-skills scripts.
+
+Used by all scripts in this skill. Uses Python stdlib only — no external dependencies.
+
+This file is the canonical source. It must be copied verbatim into every
+adgine-geo-* skill folder's scripts/ directory. The sync linter at
+scripts/sync-skills/sync-skills.sh (in the GEOAgent repo) flags any drift.
+"""
+import os
+import sys
+import json
+import time
+import atexit
+import unicodedata
+import urllib.request as _req
+import urllib.error as _uerr
+import urllib.parse as _up
+
+def _load_dot_env():
+    """Load .env from the repo root (adgine-geo-skills/) into os.environ.
+
+    Resolved relative to this file's location, so it works regardless of the
+    agent's working directory (e.g. Hermes, OpenClaw, or any other runtime).
+    Existing environment variables are never overwritten.
+    """
+    if os.environ.get("GEO_API_KEY"):
+        return
+    # _client.py is at <repo_root>/adgine-geo-<skill>/scripts/_client.py
+    repo_root = os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    )
+    env_path = os.path.join(repo_root, ".env")
+    if not os.path.isfile(env_path):
+        return
+    with open(env_path) as _f:
+        for _line in _f:
+            _line = _line.strip()
+            if not _line or _line.startswith("#") or "=" not in _line:
+                continue
+            _k, _, _v = _line.partition("=")
+            _k = _k.strip()
+            _v = _v.strip()
+            if _k and _k not in os.environ:
+                os.environ[_k] = _v
+
+
+_load_dot_env()
+
+_VERSION_UNCHECKED = object()
+_version_state = _VERSION_UNCHECKED
+
+
+def _repo_root():
+    return os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    )
+
+
+def _load_check_version_module():
+    import importlib.util
+    path = os.path.join(_repo_root(), "scripts", "check_version.py")
+    if not os.path.isfile(path):
+        return None
+    spec = importlib.util.spec_from_file_location("geo_check_version", path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def _load_version_state():
+    global _version_state
+    if _version_state is not _VERSION_UNCHECKED:
+        return _version_state
+    _version_state = None
+    try:
+        mod = _load_check_version_module()
+        if mod is not None:
+            _version_state = mod.get_state()
+    except Exception:
+        pass
+    return _version_state
+
+
+def _print_version_notice():
+    """Emit machine + human hints at import if a newer version exists."""
+    state = _load_version_state()
+    if not state or not state.get("update_available"):
+        return
+    cur, lat = state["current"], state["latest"]
+    try:
+        mod = _load_check_version_module()
+        if mod is not None:
+            inline = mod.format_user_inline(state)
+            if inline:
+                sys.stdout.write(inline + "\n\n")
+                sys.stdout.flush()
+    except Exception:
+        pass
+    if state.get("install_type") == "git":
+        msg = (f"adgine-geo-skills {lat} available (current {cur}). "
+               "Tell me: 请帮我更新 adgine-geo-skills 到最新版本")
+    else:
+        msg = (f"adgine-geo-skills {lat} available (current {cur}). "
+               f"Download: {state.get('release_url', '')}")
+    notice = {"update": {"current": cur, "latest": lat, "message": msg}}
+    try:
+        line = f"_notice: {json.dumps(notice, ensure_ascii=False)}\n\n"
+        sys.stdout.write(line)
+        sys.stdout.flush()
+    except Exception:
+        pass
+
+
+def _print_version_footer():
+    """Emit human-readable footer at process exit (WorkBuddy-compatible)."""
+    state = _load_version_state()
+    if not state or not state.get("update_available"):
+        return
+    try:
+        mod = _load_check_version_module()
+        if mod is None:
+            return
+        footer = mod.format_user_footer(state)
+        if footer:
+            sys.stdout.write("\n" + footer + "\n")
+            sys.stdout.flush()
+    except Exception:
+        pass
+
+
+_print_version_notice()
+atexit.register(_print_version_footer)
+
+
+def get_api_config():
+    """Read GEO_API_KEY and GEO_API_BASE_URL from environment.
+
+    Exits with a helpful message if GEO_API_KEY is not set.
+    Returns (key, base_url).
+    """
+    key = os.environ.get("GEO_API_KEY", "")
+    base = os.environ.get("GEO_API_BASE_URL", "https://platform.adgine.ai").rstrip("/")
+    if not key:
+        repo_root = os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+        env_path = os.path.join(repo_root, ".env")
+        example_path = os.path.join(repo_root, ".env.example")
+        setup_path = os.path.join(repo_root, "setup.py")
+        print("ERROR: GEO_API_KEY is not set.")
+        print(f"  Expected location: {env_path}")
+        print()
+        print("  One-shot fix (recommended):")
+        print(f"    python3 {setup_path} <YOUR_KEY>")
+        print()
+        print("  Or set it manually:")
+        if not os.path.isfile(env_path):
+            print(f"    cp {example_path} {env_path}")
+        print(f"    edit {env_path} and set GEO_API_KEY=geo_sk_live_xxx")
+        print()
+        print("  Get your key at: https://platform.adgine.ai")
+        print("  The .env file is gitignored — your key stays local and private.")
+        print()
+        print("  NOTE: adgine-geo-site-audit does NOT require an API key.")
+        print("    Run directly: python3 adgine-geo-site-audit/scripts/geo_collect.py <url>")
+        sys.exit(1)
+    return key, base
+
+
+def get_project_id(arg_value=None):
+    """Resolve project ID from argument or GEO_PROJECT_ID env var.
+
+    Exits with instructions if neither is set.
+    """
+    pid = arg_value or os.environ.get("GEO_PROJECT_ID", "")
+    if not pid:
+        print("ERROR: Project ID is required but not set.")
+        print("  Option 1: export GEO_PROJECT_ID=<project-id>")
+        print("  Option 2: pass --project-id <id> to this script")
+        print("  Run list_projects.py from the adgine-geo-projects skill to see your available projects.")
+        sys.exit(1)
+    return pid
+
+
+def _do_request(method, url, key, body=None, timeout=30):
+    """Execute an HTTP request and return parsed JSON.
+
+    Exits with an error message on HTTP errors or network failures.
+    """
+    data = json.dumps(body).encode("utf-8") if body is not None else None
+    headers = {
+        "Authorization": f"Bearer {key}",
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "User-Agent": "geo-skills/1.0",
+    }
+    request = _req.Request(url, data=data, headers=headers, method=method)
+    try:
+        with _req.urlopen(request, timeout=timeout) as resp:
+            raw = resp.read().decode("utf-8")
+            return json.loads(raw) if raw else {}
+    except _uerr.HTTPError as e:
+        raw = e.read().decode("utf-8")[:400]
+        try:
+            err_data = json.loads(raw)
+            msg = err_data.get("message") or err_data.get("detail") or raw
+        except Exception:
+            msg = raw
+        if e.code == 401:
+            print("ERROR: Unauthorized — API key is invalid or revoked.")
+            print("  Generate a new key: https://platform.adgine.ai")
+        elif e.code == 403:
+            print("ERROR: Forbidden — insufficient permissions for this operation.")
+        elif e.code == 404:
+            print(f"ERROR: Not found — {msg}")
+        else:
+            print(f"ERROR: HTTP {e.code} — {msg}")
+        sys.exit(1)
+    except Exception as e:
+        print(f"ERROR: Request failed — {e}")
+        sys.exit(1)
+
+
+def api_get(path, key, base, params=None, timeout=30):
+    url = f"{base}{path}"
+    if params:
+        clean = {k: str(v) for k, v in params.items() if v is not None}
+        if clean:
+            url += "?" + _up.urlencode(clean)
+    return _do_request("GET", url, key, timeout=timeout)
+
+
+def api_post(path, key, base, body=None, timeout=30):
+    return _do_request("POST", f"{base}{path}", key, body, timeout=timeout)
+
+
+def api_patch(path, key, base, body=None, timeout=30):
+    return _do_request("PATCH", f"{base}{path}", key, body, timeout=timeout)
+
+
+def api_put(path, key, base, body=None, timeout=30):
+    return _do_request("PUT", f"{base}{path}", key, body, timeout=timeout)
+
+
+def api_delete(path, key, base, timeout=30):
+    return _do_request("DELETE", f"{base}{path}", key, timeout=timeout)
+
+
+def extract_data(result):
+    """Extract the .data field from a standard geo-api envelope response.
+
+    On success the API returns {"code": 0, "data": <payload>, "message": "ok"}.
+    On non-zero code, this prints the message and exits(1).
+    """
+    if not isinstance(result, dict):
+        return result
+    if "code" in result and result.get("code") not in (0, None):
+        msg = result.get("message") or result.get("detail") or "request failed"
+        print(f"ERROR: API returned code={result.get('code')} — {msg}")
+        sys.exit(1)
+    return result.get("data", result)
+
+
+def poll_job(status_path, key, base, interval=3, max_wait=300,
+             terminal=("completed", "failed", "done", "success", "error")):
+    """Poll a job/task endpoint until it reaches a terminal state.
+
+    Prints an inline spinner with the current phase. Returns the final job dict.
+    """
+    elapsed = 0
+    frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    idx = 0
+    last_job = {}
+    while elapsed < max_wait:
+        result = api_get(status_path, key, base)
+        last_job = extract_data(result) or {}
+        status = (last_job.get("status") or "").lower()
+        phase = last_job.get("current_phase") or last_job.get("phase") or status or "pending"
+        print(f"\r  {frames[idx % len(frames)]} {phase}... ({elapsed}s)", end="", flush=True)
+        idx += 1
+        if status in terminal:
+            print()  # newline after spinner
+            return last_job
+        time.sleep(interval)
+        elapsed += interval
+    print()
+    print(f"WARNING: Job is still running after {max_wait}s. Check status manually.")
+    return last_job
+
+
+def print_json(data):
+    """Print data as formatted JSON (UTF-8 safe)."""
+    print(json.dumps(data, ensure_ascii=False, indent=2))
+
+
+def fmt_change(value):
+    """Format a numeric change indicator per CONVENTIONS.md §4.
+
+    Returns: '+N' / '-N' / '0' / '--' (None becomes '--').
+    """
+    if value is None:
+        return "--"
+    try:
+        n = float(value)
+    except (TypeError, ValueError):
+        return "--"
+    if n == 0:
+        return "0"
+    sign = "+" if n > 0 else ""
+    if n == int(n):
+        return f"{sign}{int(n):,}"
+    return f"{sign}{n:,.1f}"
+
+
+def truncate(text, n=60, ellipsis="…"):
+    """Truncate text to n characters, adding ellipsis if cut. ASCII-safe for tables."""
+    if text is None:
+        return "--"
+    s = str(text)
+    if len(s) <= n:
+        return s
+    return s[: max(0, n - len(ellipsis))] + ellipsis
+
+def display_width(s):
+    """Return the display width of a string (CJK chars count as 2 columns)."""
+    w = 0
+    for c in str(s):
+        eaw = unicodedata.east_asian_width(c)
+        w += 2 if eaw in ('W', 'F') else 1
+    return w
+
+
+def pad(s, width, align='left'):
+    """Pad string to display width for CJK-aware table alignment.
+    Replaces f'{s:<N}' (align='left') and f'{s:>N}' (align='right').
+    """
+    s = str(s)
+    dw = display_width(s)
+    spaces = max(0, width - dw) * ' '
+    return spaces + s if align == 'right' else s + spaces

package/skills/adgine-geo-billing/scripts/get_credits.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Query the current user's credits balance (subscription + purchased pools).
+
+Usage:
+  python3 scripts/get_credits.py [--json]
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import get_api_config, api_get, extract_data, print_json
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Get current credits balance")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    args = parser.parse_args()
+
+    key, base = get_api_config()
+    result = api_get("/api/payments/credits/me", key, base)
+    data = extract_data(result)
+
+    if args.json:
+        print_json(data)
+        return
+
+    if not data:
+        print("Credits information unavailable (service may be offline).")
+        return
+
+    sub_bal = data.get("subscription_balance", 0)
+    pur_bal = data.get("purchased_balance", 0)
+    total = sub_bal + pur_bal
+
+    print("Credits Balance")
+    print()
+    print("```")
+    print("┌──────────────────────┬──────────────┐")
+    print("│ Pool                 │      Balance │")
+    print("├──────────────────────┼──────────────┤")
+    print(f"│ Subscription Credits │ {sub_bal:>12,} │")
+    print(f"│ Purchased Credits    │ {pur_bal:>12,} │")
+    print("├──────────────────────┼──────────────┤")
+    print(f"│ Total                │ {total:>12,} │")
+    print("└──────────────────────┴──────────────┘")
+    print("```")
+
+
+if __name__ == "__main__":
+    main()

package/skills/adgine-geo-billing/scripts/get_credits_pricing.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Query credits pricing information (unit price, min/max, presets).
+
+Usage:
+  python3 scripts/get_credits_pricing.py [--json]
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import get_api_config, api_get, extract_data, print_json
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Get credits pricing info")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    args = parser.parse_args()
+
+    key, base = get_api_config()
+    result = api_get("/api/payments/credits/pricing", key, base)
+    data = extract_data(result) or {}
+
+    if args.json:
+        print_json(data)
+        return
+
+    if not data:
+        print("Credits pricing information unavailable.")
+        return
+
+    unit = data.get("unit_price_cents_per_credit", 1)
+    min_c = data.get("min_credits", 1000)
+    step = data.get("step", 100)
+    max_c = data.get("max_credits", 100000)
+    presets = data.get("presets", [])
+
+    print("Credits Pricing")
+    print()
+    print(f"  Unit price: ${unit / 100:.2f} per credit ({unit} cent)")
+    print(f"  Minimum purchase: {min_c:,} credits (${min_c * unit / 100:.2f})")
+    print(f"  Maximum purchase: {max_c:,} credits (${max_c * unit / 100:.2f})")
+    print(f"  Step: {step:,} credits")
+    print()
+    if presets:
+        print("  Preset options:")
+        for p in presets:
+            print(f"    - {p:,} credits = ${p * unit / 100:.2f}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/adgine-geo-billing/scripts/get_subscription.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""Query the current user's active GEO subscription.
+
+Usage:
+  python3 scripts/get_subscription.py [--json]
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import get_api_config, api_get, extract_data, print_json, truncate, pad
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Get current GEO subscription")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    args = parser.parse_args()
+
+    key, base = get_api_config()
+    result = api_get("/api/payments/subscription", key, base)
+    data = extract_data(result) or {}
+
+    if args.json:
+        print_json(data)
+        return
+
+    if not data or (isinstance(data, dict) and not data):
+        print("No active subscription.")
+        return
+
+    print("Current Subscription")
+    print()
+    print("```")
+    print("┌────────────────────┬──────────────────────────────┐")
+    print("│ Field              │ Value                        │")
+    print("├────────────────────┼──────────────────────────────┤")
+    for k in ("plan", "plan_name", "status", "interval", "current_period_start",
+              "current_period_end", "renews_at", "cancel_at_period_end",
+              "trial_end", "credits_remaining", "credits_total"):
+        if k in data:
+            print(f"│ {pad(k, 18)} │ {pad(truncate(data.get(k), 28), 28)} │")
+    print("└────────────────────┴──────────────────────────────┘")
+    print("```")
+
+
+if __name__ == "__main__":
+    main()

package/skills/adgine-geo-billing/scripts/list_plans.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""List all GEO platform subscription plans.
+
+Public endpoint — works without project context but still requires GEO_API_KEY.
+
+Usage:
+  python3 scripts/list_plans.py [--json]
+"""
+import sys
+import os
+import argparse
+
+sys.path.insert(0, os.path.dirname(__file__))
+from _client import get_api_config, api_get, extract_data, print_json, truncate, pad
+
+
+def _fmt_price(p):
+    if p is None:
+        return "--"
+    try:
+        f = float(p)
+        if f == int(f):
+            return f"{int(f):,}"
+        return f"{f:,.2f}"
+    except (TypeError, ValueError):
+        return str(p)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="List GEO subscription plans")
+    parser.add_argument("--json", action="store_true", help="Output raw JSON")
+    args = parser.parse_args()
+
+    key, base = get_api_config()
+    result = api_get("/api/payments/plans", key, base)
+    data = extract_data(result)
+    items = data if isinstance(data, list) else (data or {}).get("plans", [])
+
+    if args.json:
+        print_json(items)
+        return
+
+    if not items:
+        print("No plans available.")
+        return
+
+    print("Available Plans")
+    print()
+    print("```")
+    print("┌────────────────────┬──────────┬──────────┬──────────────────────────┐")
+    print("│ Plan               │    Price │ Interval │ Notes                    │")
+    print("├────────────────────┼──────────┼──────────┼──────────────────────────┤")
+    for p in items:
+        name = truncate(p.get("name") or p.get("display_name"), 18)
+        price = _fmt_price(p.get("price") or p.get("amount"))
+        currency = p.get("currency") or ""
+        price_str = f"{price} {currency}".strip()
+        interval = truncate(p.get("interval") or p.get("billing_cycle") or "--", 8)
+        note = truncate(p.get("description") or "", 24)
+        print(f"│ {pad(name, 18)} │ {price_str:>8} │ {pad(interval, 8)} │ {pad(note, 24)} │")
+    print("└────────────────────┴──────────┴──────────┴──────────────────────────┘")
+    print("```")
+
+
+if __name__ == "__main__":
+    main()