netdata-cli 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

netdata_cli/__init__.py

@@ -1,3 +1,3 @@
 """netdata-cli — A powerful CLI for the Netdata Agent REST API."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

netdata_cli/cli.py

@@ -1,13 +1,18 @@
-"""netdata-cli — CLI entry point."""
+"""netdata-cli — CLI entry point.
+
+Combines Netdata REST API commands with MCP (Model Context Protocol) tools.
+"""
 
 from __future__ import annotations
 
+import json
 import sys
 
 import click
 
 from . import __version__
 from .client import NetdataClient, NetdataError
+from .mcp_client import MCPClient, MCPError
 from .formatters import (
     HAS_RICH,
     console,
@@ -26,7 +31,11 @@ def _client(url: str, timeout: int) -> NetdataClient:
     return NetdataClient(base_url=url, timeout=timeout)
 
 
-def _handle_error(exc: NetdataError) -> None:
+def _mcp_client(url: str, timeout: int) -> MCPClient:
+    return MCPClient(base_url=url, timeout=timeout)
+
+
+def _handle_error(exc: Exception) -> None:
     msg = f"Error: {exc}"
     if console:
         console.print(f"[bold red]{msg}[/]")
@@ -35,6 +44,16 @@ def _handle_error(exc: NetdataError) -> None:
     sys.exit(1)
 
 
+def _output(data, as_json: bool, title: str = "") -> None:
+    """Output data as JSON or pretty-printed."""
+    if as_json:
+        print_json(data)
+    elif HAS_RICH and isinstance(data, (dict, list)):
+        console.print_json(json.dumps(data, default=str, ensure_ascii=False))
+    else:
+        print(json.dumps(data, indent=2, default=str, ensure_ascii=False))
+
+
 # ------------------------------------------------------------------
 # Root group
 # ------------------------------------------------------------------
@@ -54,18 +73,30 @@ def _handle_error(exc: NetdataError) -> None:
 @click.option("--json", "-j", "as_json", is_flag=True, help="Output raw JSON.")
 @click.pass_context
 def cli(ctx: click.Context, url: str, timeout: int, as_json: bool) -> None:
-    """netdata-cli — A powerful CLI for the Netdata Agent REST API.
+    """netdata-cli — A powerful CLI for the Netdata Agent REST API + MCP.
 
     Query metrics, charts, alarms, functions, and agent info from the
     command line.  Supports rich tables, JSON output, and time filtering.
 
+    REST API commands: info, ping, charts, chart, data, alarms, alarm-log,
+                       allmetrics, function, functions, collectors
+
+    MCP commands:      mcp list-tools, mcp nodes, mcp metrics, mcp query,
+                       mcp anomalies, mcp correlated, mcp alerts, etc.
+
     Set NETDATA_URL env var to change the default agent address.
     """
     ctx.ensure_object(dict)
     ctx.obj["client"] = _client(url, timeout)
+    ctx.obj["mcp_client"] = _mcp_client(url, timeout)
     ctx.obj["as_json"] = as_json
 
 
+# ==================================================================
+# REST API COMMANDS (existing)
+# ==================================================================
+
+
 # ------------------------------------------------------------------
 # info
 # ------------------------------------------------------------------
@@ -134,11 +165,9 @@ def charts(ctx: click.Context, query: str | None, chart_type: str | None, limit:
         for chart_id, info in items.items():
             entry = {"id": chart_id, **info}
 
-            # type filter
             if chart_type and info.get("type", "") != chart_type:
                 continue
 
-            # text search
             if query:
                 q = query.lower()
                 searchable = " ".join(
@@ -258,7 +287,6 @@ def alarms(ctx: click.Context, show_all: bool, active_only: bool) -> None:
                 if a.get("status", "").upper() in ("WARNING", "CRITICAL")
             ]
 
-        # sort by status severity
         severity_order = {"CRITICAL": 0, "WARNING": 1, "UNDEFINED": 2, "CLEAR": 3, "REMOVED": 4}
         alarm_list.sort(key=lambda a: severity_order.get(a.get("status", "").upper(), 5))
 
@@ -292,7 +320,6 @@ def alarm_log(ctx: click.Context, after: int, unique: bool) -> None:
         else:
             entries = c.alarm_log(after=after if after else 0)
 
-        # Normalize — API returns dict with 'alarms' key or a list
         if isinstance(entries, dict):
             entries = entries.get("alarms", [])
         if isinstance(entries, list):
@@ -325,7 +352,6 @@ def allmetrics(ctx: click.Context, fmt: str) -> None:
                 if ctx.obj["as_json"]:
                     print_json(data)
                 else:
-                    # Show summary
                     for name in sorted(data.keys())[:30]:
                         entry = data[name]
                         dims = entry.get("dimensions", {})
@@ -448,6 +474,438 @@ def collectors(ctx: click.Context) -> None:
         _handle_error(exc)
 
 
+# ==================================================================
+# MCP COMMANDS (new)
+# ==================================================================
+
+
+@cli.group()
+@click.pass_context
+def mcp(ctx: click.Context) -> None:
+    """MCP (Model Context Protocol) commands — ML-powered analysis.
+
+    These commands use Netdata's MCP server for anomaly detection,
+    metric correlations, and advanced querying.
+    """
+    pass
+
+
+# ------------------------------------------------------------------
+# mcp ping
+# ------------------------------------------------------------------
+
+
+@mcp.command()
+@click.pass_context
+def ping(ctx: click.Context) -> None:
+    """Check if MCP server is reachable."""
+    try:
+        ok = ctx.obj["mcp_client"].ping()
+        if ok:
+            msg = "MCP pong ✓"
+            if console:
+                console.print(f"[bold green]{msg}[/]")
+            else:
+                print(msg)
+        else:
+            msg = "MCP server not responding"
+            if console:
+                console.print(f"[bold red]{msg}[/]")
+            else:
+                print(msg)
+            sys.exit(1)
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp list-tools
+# ------------------------------------------------------------------
+
+
+@mcp.command("list-tools")
+@click.pass_context
+def mcp_list_tools(ctx: click.Context) -> None:
+    """List available MCP tools."""
+    try:
+        tools = ctx.obj["mcp_client"].list_tools()
+        if ctx.obj["as_json"]:
+            print_json(tools)
+            return
+
+        if HAS_RICH:
+            from rich.table import Table
+
+            t = Table(title=f"MCP Tools ({len(tools)})")
+            t.add_column("Name", style="cyan")
+            t.add_column("Description", max_width=70)
+            for tool in tools:
+                t.add_row(tool.get("name", "?"), tool.get("description", "")[:70])
+            console.print(t)
+        else:
+            for tool in tools:
+                print(f"  {tool.get('name', '?')}: {tool.get('description', '')[:80]}")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp nodes
+# ------------------------------------------------------------------
+
+
+@mcp.command()
+@click.option("--metrics", "-m", multiple=True, help="Filter nodes by metric name.")
+@click.pass_context
+def nodes(ctx: click.Context, metrics: tuple) -> None:
+    """List monitored nodes."""
+    try:
+        data = ctx.obj["mcp_client"].list_nodes(list(metrics) if metrics else None)
+        _output(data, ctx.obj["as_json"], "Nodes")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp nodes-details
+# ------------------------------------------------------------------
+
+
+@mcp.command("nodes-details")
+@click.option("--node", "-n", multiple=True, help="Node ID or hostname.")
+@click.pass_context
+def nodes_details(ctx: click.Context, node: tuple) -> None:
+    """Get detailed node information (hardware, OS, capabilities)."""
+    try:
+        data = ctx.obj["mcp_client"].get_nodes_details(list(node) if node else None)
+        _output(data, ctx.obj["as_json"], "Node Details")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp metrics
+# ------------------------------------------------------------------
+
+
+@mcp.command()
+@click.argument("query", required=False)
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.pass_context
+def metrics(ctx: click.Context, query: str | None, node: tuple) -> None:
+    """Search available metrics (contexts).
+
+    \b
+    Examples:
+      nd mcp metrics                     # list all
+      nd mcp metrics "*nginx*"           # pattern search
+      nd mcp metrics "q:mysql|redis"     # full-text search
+    """
+    try:
+        q = query or ""
+        if q.startswith("q:"):
+            q = q[2:]
+        data = ctx.obj["mcp_client"].list_metrics(
+            q=q,
+            nodes=list(node) if node else None,
+        )
+        _output(data, ctx.obj["as_json"], "Metrics")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp metrics-details
+# ------------------------------------------------------------------
+
+
+@mcp.command("metrics-details")
+@click.argument("metrics_names", nargs=-1, required=True)
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.pass_context
+def metrics_details(ctx: click.Context, metrics_names: tuple, node: tuple) -> None:
+    """Get comprehensive metadata for specific metrics.
+
+    \b
+    Examples:
+      nd mcp metrics-details system.cpu system.ram
+      nd mcp metrics-details disk.util.* --node ubuntuserver
+    """
+    try:
+        data = ctx.obj["mcp_client"].get_metrics_details(
+            list(metrics_names),
+            nodes=list(node) if node else None,
+        )
+        _output(data, ctx.obj["as_json"], "Metrics Details")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp query
+# ------------------------------------------------------------------
+
+
+@mcp.command()
+@click.argument("metric")
+@click.option("--dimensions", "-d", multiple=True, help="Specific dimensions to query.")
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.option("--after", "-a", default=-300, show_default=True, help="Start time (seconds from now).")
+@click.option("--before", "-b", default=0, show_default=True, help="End time (0=now).")
+@click.option("--points", "-p", default=20, show_default=True, help="Number of data points.")
+@click.option("--time-group", "-g", default="average", show_default=True, help="Time grouping: average, min, max, sum.")
+@click.option("--group-by", multiple=True, default=["dimension"], help="Group by: dimension, instance, node.")
+@click.option("--aggregation", default="average", show_default=True, help="Aggregation: average, sum, min, max.")
+@click.option("--cardinality-limit", default=10, show_default=True, help="Max items returned.")
+@click.pass_context
+def query(
+    ctx: click.Context,
+    metric: str,
+    dimensions: tuple,
+    node: tuple,
+    after: int,
+    before: int,
+    points: int,
+    time_group: str,
+    group_by: tuple,
+    aggregation: str,
+    cardinality_limit: int,
+) -> None:
+    """Query time-series metrics with ML anomaly detection.
+
+    \b
+    Examples:
+      nd mcp query system.cpu --after -60 --points 10
+      nd mcp query system.ram -d used -d cached -d free
+      nd mcp query disk.util.* --group-by dimension,node
+      nd mcp query net.drops --after -3600 --aggregation sum
+    """
+    try:
+        data = ctx.obj["mcp_client"].query_metrics(
+            metric=metric,
+            dimensions=list(dimensions) if dimensions else None,
+            nodes=list(node) if node else None,
+            after=after,
+            before=before,
+            points=points,
+            time_group=time_group,
+            group_by=list(group_by) if group_by else ["dimension"],
+            aggregation=aggregation,
+            cardinality_limit=cardinality_limit,
+        )
+        _output(data, ctx.obj["as_json"], f"Query: {metric}")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp anomalies
+# ------------------------------------------------------------------
+
+
+@mcp.command()
+@click.option("--after", "-a", default=-3600, show_default=True, help="Start time (seconds from now).")
+@click.option("--before", "-b", default=0, show_default=True, help="End time (0=now).")
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.pass_context
+def anomalies(ctx: click.Context, after: int, before: int, node: tuple) -> None:
+    """Find metrics detected as anomalous by ML models.
+
+    \b
+    Examples:
+      nd mcp anomalies                    # last hour
+      nd mcp anomalies --after -86400     # last 24h
+      nd mcp anomalies --after -300       # last 5 min
+    """
+    try:
+        data = ctx.obj["mcp_client"].find_anomalous_metrics(
+            after=after,
+            before=before,
+            nodes=list(node) if node else None,
+        )
+        _output(data, ctx.obj["as_json"], "Anomalous Metrics")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp correlated
+# ------------------------------------------------------------------
+
+
+@mcp.command()
+@click.option("--after", "-a", default=-3600, show_default=True, help="Start time (seconds from now).")
+@click.option("--before", "-b", default=0, show_default=True, help="End time (0=now).")
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.pass_context
+def correlated(ctx: click.Context, after: int, before: int, node: tuple) -> None:
+    """Find metrics that changed significantly during a time period.
+
+    Compares the specified window against a 4x earlier baseline.
+
+    \b
+    Examples:
+      nd mcp correlated                    # last hour vs previous 4h
+      nd mcp correlated --after -300       # last 5min vs previous 20min
+    """
+    try:
+        data = ctx.obj["mcp_client"].find_correlated_metrics(
+            after=after,
+            before=before,
+            nodes=list(node) if node else None,
+        )
+        _output(data, ctx.obj["as_json"], "Correlated Metrics")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp unstable
+# ------------------------------------------------------------------
+
+
+@mcp.command()
+@click.option("--after", "-a", default=-3600, show_default=True, help="Start time (seconds from now).")
+@click.option("--before", "-b", default=0, show_default=True, help="End time (0=now).")
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.pass_context
+def unstable(ctx: click.Context, after: int, before: int, node: tuple) -> None:
+    """Find metrics with highest variability (coefficient of variation).
+
+    \b
+    Examples:
+      nd mcp unstable                     # last hour
+      nd mcp unstable --after -86400      # last 24h
+    """
+    try:
+        data = ctx.obj["mcp_client"].find_unstable_metrics(
+            after=after,
+            before=before,
+            nodes=list(node) if node else None,
+        )
+        _output(data, ctx.obj["as_json"], "Unstable Metrics")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp mcp-alerts
+# ------------------------------------------------------------------
+
+
+@mcp.command("mcp-alerts")
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.pass_context
+def mcp_alerts(ctx: click.Context, node: tuple) -> None:
+    """List active alerts (WARNING/CRITICAL) via MCP."""
+    try:
+        data = ctx.obj["mcp_client"].list_raised_alerts(
+            nodes=list(node) if node else None,
+        )
+        _output(data, ctx.obj["as_json"], "Active Alerts (MCP)")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp all-alerts
+# ------------------------------------------------------------------
+
+
+@mcp.command("all-alerts")
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.pass_context
+def all_alerts(ctx: click.Context, node: tuple) -> None:
+    """List all alerts including cleared and uninitialized."""
+    try:
+        data = ctx.obj["mcp_client"].list_running_alerts(
+            nodes=list(node) if node else None,
+        )
+        _output(data, ctx.obj["as_json"], "All Alerts (MCP)")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp alert-history
+# ------------------------------------------------------------------
+
+
+@mcp.command("alert-history")
+@click.option("--after", "-a", default=-3600, show_default=True, help="Start time (seconds from now).")
+@click.option("--before", "-b", default=0, show_default=True, help="End time (0=now).")
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.pass_context
+def alert_history(ctx: click.Context, after: int, before: int, node: tuple) -> None:
+    """Show alert state transitions (history).
+
+    \b
+    Examples:
+      nd mcp alert-history                    # last hour
+      nd mcp alert-history --after -86400     # last 24h
+    """
+    try:
+        data = ctx.obj["mcp_client"].list_alert_transitions(
+            after=after,
+            before=before,
+            nodes=list(node) if node else None,
+        )
+        _output(data, ctx.obj["as_json"], "Alert History (MCP)")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp functions
+# ------------------------------------------------------------------
+
+
+@mcp.command("mcp-functions")
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.pass_context
+def mcp_functions(ctx: click.Context, node: tuple) -> None:
+    """List available Netdata functions via MCP."""
+    try:
+        data = ctx.obj["mcp_client"].list_functions(
+            nodes=list(node) if node else None,
+        )
+        _output(data, ctx.obj["as_json"], "Functions (MCP)")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
+# ------------------------------------------------------------------
+# mcp exec
+# ------------------------------------------------------------------
+
+
+@mcp.command("exec")
+@click.argument("function_name")
+@click.option("--node", "-n", multiple=True, help="Filter by node.")
+@click.option("--after", "-a", default=0, help="Start time (seconds from now).")
+@click.option("--before", "-b", default=0, help="End time (0=now).")
+@click.pass_context
+def mcp_exec(ctx: click.Context, function_name: str, node: tuple, after: int, before: int) -> None:
+    """Execute a Netdata function via MCP.
+
+    \b
+    Examples:
+      nd mcp exec processes
+      nd mcp exec network-connections --node ubuntuserver
+      nd mcp exec systemd-journal --after -3600
+    """
+    try:
+        data = ctx.obj["mcp_client"].execute_function(
+            function_name=function_name,
+            nodes=list(node) if node else None,
+            after=after,
+            before=before,
+        )
+        _output(data, ctx.obj["as_json"], f"Function: {function_name}")
+    except MCPError as exc:
+        _handle_error(exc)
+
+
 # ------------------------------------------------------------------
 # Top-level entry
 # ------------------------------------------------------------------

netdata_cli/mcp_client.py

@@ -0,0 +1,263 @@
+"""Netdata MCP client — JSON-RPC 2.0 over HTTP."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import requests
+
+
+class MCPError(Exception):
+    """Error communicating with Netdata MCP server."""
+
+
+class MCPClient:
+    """Thin wrapper around the Netdata MCP server (JSON-RPC 2.0)."""
+
+    def __init__(self, base_url: str = "http://localhost:19999", timeout: int = 30):
+        self.base_url = base_url.rstrip("/")
+        self.mcp_url = f"{self.base_url}/mcp"
+        self.timeout = timeout
+        self._session = requests.Session()
+        self._session.headers.update({"Content-Type": "application/json"})
+        self._id = 0
+
+    def _call(self, method: str, params: dict | None = None) -> Any:
+        """Make a JSON-RPC 2.0 call to the MCP server."""
+        self._id += 1
+        payload: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "id": self._id,
+            "method": method,
+        }
+        if params is not None:
+            payload["params"] = params
+
+        try:
+            resp = self._session.post(
+                self.mcp_url,
+                json=payload,
+                timeout=self.timeout,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+        except requests.ConnectionError:
+            raise MCPError(
+                f"Cannot connect to MCP at {self.mcp_url}. "
+                "Is Netdata running and MCP enabled?"
+            )
+        except requests.Timeout:
+            raise MCPError(f"MCP request timed out after {self.timeout}s")
+        except requests.HTTPError as exc:
+            raise MCPError(f"MCP HTTP error: {exc}")
+        except (ValueError, json.JSONDecodeError):
+            raise MCPError(f"Invalid JSON from MCP at {self.mcp_url}")
+
+        if "error" in data:
+            err = data["error"]
+            msg = err.get("message", "Unknown MCP error")
+            raise MCPError(f"MCP error: {msg}")
+
+        return data.get("result", {})
+
+    # ------------------------------------------------------------------
+    # Server info
+    # ------------------------------------------------------------------
+
+    def initialize(self) -> dict:
+        """Initialize MCP session and get server capabilities."""
+        return self._call("initialize", {
+            "protocolVersion": "2024-11-05",
+            "capabilities": {},
+            "clientInfo": {"name": "netdata-cli", "version": "1.0"},
+        })
+
+    def ping(self) -> bool:
+        """Check if MCP server is reachable."""
+        try:
+            result = self._call("initialize", {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {"name": "netdata-cli", "version": "1.0"},
+            })
+            return bool(result.get("serverInfo"))
+        except MCPError:
+            return False
+
+    # ------------------------------------------------------------------
+    # Tools
+    # ------------------------------------------------------------------
+
+    def list_tools(self) -> list[dict]:
+        """List available MCP tools."""
+        result = self._call("tools/list", {})
+        return result.get("tools", [])
+
+    def call_tool(self, name: str, arguments: dict | None = None) -> Any:
+        """Call an MCP tool by name with arguments."""
+        result = self._call("tools/call", {
+            "name": name,
+            "arguments": arguments or {},
+        })
+        # Extract text content from MCP response
+        content = result.get("content", [])
+        for item in content:
+            if item.get("type") == "text":
+                text = item.get("text", "")
+                try:
+                    return json.loads(text)
+                except (ValueError, json.JSONDecodeError):
+                    return text
+        return content
+
+    # ------------------------------------------------------------------
+    # High-level wrappers for each MCP tool
+    # ------------------------------------------------------------------
+
+    def list_metrics(self, q: str = "", nodes: list[str] | None = None) -> Any:
+        """Search available metrics by pattern or full-text query."""
+        args: dict[str, Any] = {}
+        if q:
+            args["q"] = q
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("list_metrics", args)
+
+    def get_metrics_details(self, metrics: list[str], nodes: list[str] | None = None) -> Any:
+        """Get comprehensive metadata for specific metrics."""
+        args: dict[str, Any] = {"metrics": metrics}
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("get_metrics_details", args)
+
+    def list_nodes(self, metrics: list[str] | None = None) -> Any:
+        """List all monitored nodes."""
+        args: dict[str, Any] = {}
+        if metrics:
+            args["metrics"] = metrics
+        return self.call_tool("list_nodes", args)
+
+    def get_nodes_details(self, nodes: list[str] | None = None) -> Any:
+        """Get comprehensive node information."""
+        args: dict[str, Any] = {}
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("get_nodes_details", args)
+
+    def list_functions(self, nodes: list[str] | None = None) -> Any:
+        """List available Netdata functions."""
+        args: dict[str, Any] = {}
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("list_functions", args)
+
+    def execute_function(
+        self,
+        function_name: str,
+        nodes: list[str] | None = None,
+        after: int = 0,
+        before: int = 0,
+    ) -> Any:
+        """Execute a Netdata function (processes, connections, etc)."""
+        args: dict[str, Any] = {"function": function_name}
+        if nodes:
+            args["nodes"] = nodes
+        if after:
+            args["after"] = after
+        if before:
+            args["before"] = before
+        return self.call_tool("execute_function", args)
+
+    def query_metrics(
+        self,
+        metric: str,
+        dimensions: list[str] | None = None,
+        nodes: list[str] | None = None,
+        after: int = -300,
+        before: int = 0,
+        points: int = 20,
+        time_group: str = "average",
+        group_by: list[str] | None = None,
+        aggregation: str = "average",
+        cardinality_limit: int = 10,
+    ) -> Any:
+        """Query time-series metrics data with aggregation."""
+        args: dict[str, Any] = {
+            "metric": metric,
+            "after": after,
+            "before": before,
+            "points": points,
+            "time_group": time_group,
+            "aggregation": aggregation,
+            "cardinality_limit": cardinality_limit,
+        }
+        if dimensions:
+            args["dimensions"] = dimensions
+        if nodes:
+            args["nodes"] = nodes
+        if group_by:
+            args["group_by"] = group_by
+        return self.call_tool("query_metrics", args)
+
+    def find_correlated_metrics(
+        self,
+        after: int = -3600,
+        before: int = 0,
+        nodes: list[str] | None = None,
+    ) -> Any:
+        """Find metrics that changed significantly during a time period."""
+        args: dict[str, Any] = {"after": after, "before": before}
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("find_correlated_metrics", args)
+
+    def find_anomalous_metrics(
+        self,
+        after: int = -3600,
+        before: int = 0,
+        nodes: list[str] | None = None,
+    ) -> Any:
+        """Find metrics detected as anomalous by ML models."""
+        args: dict[str, Any] = {"after": after, "before": before}
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("find_anomalous_metrics", args)
+
+    def find_unstable_metrics(
+        self,
+        after: int = -3600,
+        before: int = 0,
+        nodes: list[str] | None = None,
+    ) -> Any:
+        """Find metrics with highest variability."""
+        args: dict[str, Any] = {"after": after, "before": before}
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("find_unstable_metrics", args)
+
+    def list_raised_alerts(self, nodes: list[str] | None = None) -> Any:
+        """List currently active alerts (WARNING/CRITICAL)."""
+        args: dict[str, Any] = {}
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("list_raised_alerts", args)
+
+    def list_running_alerts(self, nodes: list[str] | None = None) -> Any:
+        """List all alerts including cleared and uninitialized."""
+        args: dict[str, Any] = {}
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("list_running_alerts", args)
+
+    def list_alert_transitions(
+        self,
+        after: int = -3600,
+        before: int = 0,
+        nodes: list[str] | None = None,
+    ) -> Any:
+        """List recent alert state transitions."""
+        args: dict[str, Any] = {"after": after, "before": before}
+        if nodes:
+            args["nodes"] = nodes
+        return self.call_tool("list_alert_transitions", args)

{netdata_cli-0.1.0.dist-info → netdata_cli-0.2.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: netdata-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: A powerful CLI for the Netdata Agent REST API — query metrics, charts, alarms, and functions from the terminal.
-Author-email: Sosi <sosi@example.com>
+Author-email: Sosi <albertotplaza@gmail.com>
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/sosiman/netdata-cli
 Project-URL: Repository, https://github.com/sosiman/netdata-cli
@@ -35,6 +35,10 @@ Dynamic: license-file
 
 # netdata-cli
 
+[![PyPI version](https://img.shields.io/pypi/v/netdata-cli)](https://pypi.org/project/netdata-cli/)
+[![Python](https://img.shields.io/pypi/pyversions/netdata-cli)](https://pypi.org/project/netdata-cli/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
 A powerful CLI for the [Netdata](https://www.netdata.cloud/) Agent REST API.
 
 Query metrics, charts, alarms, functions, and agent info — all from the terminal.

netdata_cli-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+netdata_cli/__init__.py,sha256=98BjFSTP9kfsojaOeT-kQNw65tfi-uiWolU549sPMpM,92
+netdata_cli/cli.py,sha256=PhvxMkZo04UzvBCxHm4Pq1REyaQ-w4YAV_OJU2xhyzo,30264
+netdata_cli/client.py,sha256=T4DuVOP_CKvzpF1FiXbG1OvYvqhgO29tOqHykFCp48A,7862
+netdata_cli/formatters.py,sha256=rokGtvuwK1MsR2cMOEjza2ggL4YvqSOLnvCgCwiPm_w,11644
+netdata_cli/mcp_client.py,sha256=XNk2aKHAfnBHRjjnewuy4dxve7WfGco2YElpUoXxxXA,9076
+netdata_cli-0.2.0.dist-info/licenses/LICENSE,sha256=Tq3uYZqMEv-MzVnsiXx-L99tt5Css4jGrocf6KpFdfM,1061
+netdata_cli-0.2.0.dist-info/METADATA,sha256=UhjQzTgLYHywoA7T3ipGMb6P4C9_iuHDRLFghoikzh8,5977
+netdata_cli-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+netdata_cli-0.2.0.dist-info/entry_points.txt,sha256=15fw-SmjPRO9-1z1h0g8I2pWuyNXZDm_MmHkiDklELw,44
+netdata_cli-0.2.0.dist-info/top_level.txt,sha256=TC9SwX7mrl2Q1QDRKMs045wkb5Bg3MH1y_iAiL1jhDc,12
+netdata_cli-0.2.0.dist-info/RECORD,,

netdata_cli-0.1.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-netdata_cli/__init__.py,sha256=rIbZbYbNCaZoSgcA-IOtDHW52a1eZSUD-2ONKIaMVsM,92
-netdata_cli/cli.py,sha256=ZCfaEzf119wYfzv5ZM2kM4hjrZMC6BvpMInU8PBpszQ,14570
-netdata_cli/client.py,sha256=T4DuVOP_CKvzpF1FiXbG1OvYvqhgO29tOqHykFCp48A,7862
-netdata_cli/formatters.py,sha256=rokGtvuwK1MsR2cMOEjza2ggL4YvqSOLnvCgCwiPm_w,11644
-netdata_cli-0.1.0.dist-info/licenses/LICENSE,sha256=Tq3uYZqMEv-MzVnsiXx-L99tt5Css4jGrocf6KpFdfM,1061
-netdata_cli-0.1.0.dist-info/METADATA,sha256=QoL8zXtGoXNJFhlbCjhuhNmazh3m_u_fQ8dD9S4Fs7A,5686
-netdata_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-netdata_cli-0.1.0.dist-info/entry_points.txt,sha256=15fw-SmjPRO9-1z1h0g8I2pWuyNXZDm_MmHkiDklELw,44
-netdata_cli-0.1.0.dist-info/top_level.txt,sha256=TC9SwX7mrl2Q1QDRKMs045wkb5Bg3MH1y_iAiL1jhDc,12
-netdata_cli-0.1.0.dist-info/RECORD,,