foresight-cli 0.1.0__tar.gz

foresight_cli-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: foresight-cli
+Version: 0.1.0
+Summary: Predict system resource exhaustion before it happens.
+Author: Rishi Garg
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/foresight
+Project-URL: Repository, https://github.com/YOUR_USERNAME/foresight
+Project-URL: Issues, https://github.com/YOUR_USERNAME/foresight/issues
+Keywords: cli,monitoring,forecasting,devops,time-series,arima,machine-learning,psutil,system-monitoring
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: plotext>=5.2.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: statsmodels>=0.14.0

foresight_cli-0.1.0/foresight/cli.py

@@ -0,0 +1,478 @@
+import os
+import time
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich import box
+import plotext as plt
+
+from foresight.storage import init_db, get_snapshots, get_metric_series, VALID_METRICS
+from foresight.storage import save_snapshot
+from foresight.collector import collect_loop, collect_snapshot
+from foresight.forecaster import (
+    forecast_arima,
+    forecast_holtwinters,
+    forecast_ensemble,
+    check_threshold,
+    steps_to_human_time,
+    parse_horizon,
+)
+
+
+# ─── App Setup ────────────────────────────────────────────────────────────────
+
+app = typer.Typer(
+    name="foresight",
+    help="Predict system resource exhaustion before it happens.",
+    add_completion=False,
+)
+
+console = Console()
+
+# Smart thresholds based on real computer health standards
+METRIC_THRESHOLDS = {
+    "cpu_percent":  {"warning": 75.0,  "critical": 90.0},
+    "ram_percent":  {"warning": 80.0,  "critical": 90.0},
+    "disk_percent": {"warning": 85.0,  "critical": 95.0},
+    "ram_used_mb":  {"warning": 80.0,  "critical": 90.0},
+    "disk_used_gb": {"warning": 85.0,  "critical": 95.0},
+}
+
+VALID_MODELS = ("arima", "holtwinters", "ensemble")
+
+
+# ─── Private Helpers ──────────────────────────────────────────────────────────
+
+def _color(value: float, warning: float = 75.0, critical: float = 90.0) -> str:
+    """Return Rich color string based on value vs thresholds."""
+    if value >= critical:
+        return "bold red"
+    elif value >= warning:
+        return "yellow"
+    else:
+        return "green"
+
+
+def _run_forecast(metric: str, steps: int, model: str) -> dict:
+    """Run the selected forecast model and return result dict."""
+    if model == "arima":
+        return forecast_arima(metric=metric, steps=steps)
+    elif model == "holtwinters":
+        return forecast_holtwinters(metric=metric, steps=steps)
+    else:
+        return forecast_ensemble(metric=metric, steps=steps)
+
+
+def _validate_inputs(metric: str, model: str) -> bool:
+    """Validate metric and model. Print error and return False if invalid."""
+    if metric not in VALID_METRICS:
+        console.print(f"[red]Invalid metric '{metric}'.[/red]")
+        console.print(f"Valid metrics: {', '.join(sorted(VALID_METRICS))}")
+        return False
+    if model not in VALID_MODELS:
+        console.print(
+            f"[red]Invalid model '{model}'. "
+            f"Choose: {', '.join(VALID_MODELS)}[/red]"
+        )
+        return False
+    return True
+
+
+def _status_icon(status: str) -> str:
+    return {"critical": "🚨", "warning": "⚠️ ", "ok": "✅"}.get(status, "")
+
+
+def _status_style(status: str) -> str:
+    return {
+        "critical": "bold red",
+        "warning": "bold yellow",
+        "ok": "bold green",
+    }.get(status, "white")
+
+
+# ─── Commands ─────────────────────────────────────────────────────────────────
+
+@app.command()
+def collect(
+    interval: int = typer.Option(
+        60, help="Seconds between snapshots (default: 60s)."
+    ),
+    rounds: int = typer.Option(
+        60, help="Number of snapshots (default: 60 = 1 hour of data)."
+    ),
+) -> None:
+    """Collect system metrics every N seconds for M rounds."""
+    init_db()
+    total_minutes = rounds * interval // 60
+    console.print(
+        f"\n[bold green]Starting collection:[/bold green] "
+        f"{rounds} snapshots every {interval}s "
+        f"([cyan]~{total_minutes} minutes total[/cyan])\n"
+    )
+    collect_loop(interval_seconds=interval, rounds=rounds)
+    console.print(
+        f"\n[bold green]Done.[/bold green] "
+        f"{rounds} snapshots saved to database.\n"
+    )
+
+
+@app.command()
+def status() -> None:
+    """Show a single live snapshot of current resource usage."""
+    init_db()
+    snap = collect_snapshot()
+    save_snapshot(snap)
+
+    cpu   = snap["cpu_percent"]
+    ram   = snap["ram_percent"]
+    disk  = snap["disk_percent"]
+
+    cpu_thresh  = METRIC_THRESHOLDS["cpu_percent"]
+    ram_thresh  = METRIC_THRESHOLDS["ram_percent"]
+    disk_thresh = METRIC_THRESHOLDS["disk_percent"]
+
+    console.print("\n[bold]Current System Status[/bold]\n")
+    console.print(
+        f"  CPU   : [{_color(cpu, **cpu_thresh)}]{cpu:>5.1f}%[/{_color(cpu, **cpu_thresh)}]"
+    )
+    console.print(
+        f"  RAM   : [{_color(ram, **ram_thresh)}]{ram:>5.1f}%[/{_color(ram, **ram_thresh)}]"
+        f"  ({snap['ram_used_mb']:.0f} MB / {snap['ram_total_mb']:.0f} MB)"
+    )
+    console.print(
+        f"  Disk  : [{_color(disk, **disk_thresh)}]{disk:>5.1f}%[/{_color(disk, **disk_thresh)}]"
+        f"  ({snap['disk_used_gb']:.1f} GB / {snap['disk_total_gb']:.1f} GB)"
+    )
+    console.print(f"\n  [dim]Saved at {snap['timestamp']}[/dim]\n")
+
+
+@app.command()
+def watch(
+    interval: int = typer.Option(5,  help="Refresh every N seconds."),
+    rounds:   int = typer.Option(50, help="Stop after N refreshes."),
+) -> None:
+    """Live monitor — refreshes resource usage every N seconds. Ctrl+C to stop."""
+    init_db()
+    console.print(
+        f"\n[bold]Foresight Live Monitor[/bold] — "
+        f"refreshing every {interval}s. "
+        f"[dim]Ctrl+C to stop.[/dim]\n"
+    )
+
+    try:
+        for i in range(rounds):
+            snap = collect_snapshot()
+            save_snapshot(snap)
+
+            os.system("cls")
+
+            cpu   = snap["cpu_percent"]
+            ram   = snap["ram_percent"]
+            disk  = snap["disk_percent"]
+
+            cpu_thresh  = METRIC_THRESHOLDS["cpu_percent"]
+            ram_thresh  = METRIC_THRESHOLDS["ram_percent"]
+            disk_thresh = METRIC_THRESHOLDS["disk_percent"]
+
+            console.print(
+                f"[bold]Foresight Live Monitor[/bold]  "
+                f"[dim]{snap['timestamp']}[/dim]\n"
+            )
+
+            cpu_bar  = "█" * int(cpu  / 5)
+            ram_bar  = "█" * int(ram  / 5)
+            disk_bar = "█" * int(disk / 5)
+
+            console.print(
+                f"  CPU   : [{_color(cpu,  **cpu_thresh)}]{cpu:>5.1f}%[/{_color(cpu, **cpu_thresh)}]  {cpu_bar}"
+            )
+            console.print(
+                f"  RAM   : [{_color(ram,  **ram_thresh)}]{ram:>5.1f}%[/{_color(ram, **ram_thresh)}]  {ram_bar}"
+                f"  ({snap['ram_used_mb']:.0f} MB / {snap['ram_total_mb']:.0f} MB)"
+            )
+            console.print(
+                f"  Disk  : [{_color(disk, **disk_thresh)}]{disk:>5.1f}%[/{_color(disk, **disk_thresh)}]  {disk_bar}"
+                f"  ({snap['disk_used_gb']:.1f} GB / {snap['disk_total_gb']:.1f} GB)"
+            )
+            console.print(
+                f"\n  [dim]Refresh {i+1}/{rounds} — next in {interval}s[/dim]"
+            )
+
+            if i < rounds - 1:
+                time.sleep(interval)
+
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Live monitor stopped.[/yellow]\n")
+
+
+@app.command()
+def show(
+    limit: int = typer.Option(10, help="Number of recent snapshots to display."),
+) -> None:
+    """Show recent snapshots from the database as a color-coded table."""
+    init_db()
+    snapshots = get_snapshots(limit=limit)
+
+    if not snapshots:
+        console.print(
+            "[yellow]No snapshots found. "
+            "Run 'foresight collect' first.[/yellow]"
+        )
+        raise typer.Exit()
+
+    table = Table(
+        title=f"Last {len(snapshots)} Snapshots",
+        box=box.ROUNDED,
+        show_lines=True,
+    )
+
+    table.add_column("Timestamp",      style="cyan", no_wrap=True)
+    table.add_column("CPU %",          justify="right")
+    table.add_column("RAM %",          justify="right")
+    table.add_column("RAM Used (MB)",  justify="right")
+    table.add_column("Disk %",         justify="right")
+    table.add_column("Disk Used (GB)", justify="right")
+
+    cpu_t  = METRIC_THRESHOLDS["cpu_percent"]
+    ram_t  = METRIC_THRESHOLDS["ram_percent"]
+    disk_t = METRIC_THRESHOLDS["disk_percent"]
+
+    for snap in reversed(snapshots):
+        cpu  = snap["cpu_percent"]
+        ram  = snap["ram_percent"]
+        disk = snap["disk_percent"]
+
+        table.add_row(
+            snap["timestamp"],
+            f"[{_color(cpu,  **cpu_t)}]{cpu}%[/{_color(cpu,  **cpu_t)}]",
+            f"[{_color(ram,  **ram_t)}]{ram}%[/{_color(ram,  **ram_t)}]",
+            str(snap["ram_used_mb"]),
+            f"[{_color(disk, **disk_t)}]{disk}%[/{_color(disk, **disk_t)}]",
+            str(snap["disk_used_gb"]),
+        )
+
+    console.print(table)
+
+
+@app.command()
+def chart(
+    metric: str = typer.Option("cpu_percent", help="Metric to chart."),
+    limit:  int = typer.Option(50,            help="Number of recent snapshots to plot."),
+) -> None:
+    """Render an ASCII line chart of a metric over time in the terminal."""
+    init_db()
+
+    if metric not in VALID_METRICS:
+        console.print(f"[red]Invalid metric '{metric}'.[/red]")
+        console.print(f"Valid options: {', '.join(sorted(VALID_METRICS))}")
+        raise typer.Exit()
+
+    timestamps, values = get_metric_series(metric=metric, limit=limit)
+
+    if len(values) < 2:
+        console.print(
+            "[yellow]Not enough data to chart. "
+            "Run 'foresight collect' first.[/yellow]"
+        )
+        raise typer.Exit()
+
+    short_labels = [ts[11:16] for ts in timestamps]
+    x_values     = list(range(len(values)))
+
+    plt.clear_figure()
+    plt.plot(x_values, values, label=metric, marker="braille")
+    plt.title(
+        f"{metric} — {short_labels[0]} to {short_labels[-1]} "
+        f"({len(values)} snapshots)"
+    )
+    plt.xlabel("Snapshot index")
+    plt.ylabel("Percent (%)")
+    plt.ylim(0, 100)
+    plt.plotsize(80, 20)
+    plt.show()
+
+
+@app.command()
+def forecast(
+    metric:   str = typer.Option("cpu_percent", help="Metric to forecast."),
+    horizon:  str = typer.Option("30m",         help="How far ahead: '30m', '1h', '2h'."),
+    model:    str = typer.Option("ensemble",    help="Model: arima, holtwinters, ensemble."),
+    interval: int = typer.Option(60,            help="Your collection interval in seconds."),
+) -> None:
+    """Forecast future resource usage over a time horizon (e.g. 30m, 1h, 2h)."""
+    init_db()
+
+    if not _validate_inputs(metric, model):
+        raise typer.Exit()
+
+    try:
+        steps = parse_horizon(horizon, interval_seconds=interval)
+    except ValueError as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit()
+
+    console.print(
+        f"\n[bold]Forecasting[/bold] [cyan]{metric}[/cyan] "
+        f"for next [cyan]{horizon}[/cyan] "
+        f"({steps} steps × {interval}s) "
+        f"using [cyan]{model.upper()}[/cyan]\n"
+    )
+
+    result = _run_forecast(metric, steps, model)
+
+    trend_color = {"rising": "red", "falling": "green", "stable": "yellow"}.get(
+        result["trend_summary"], "white"
+    )
+
+    console.print(f"  Last observed : {result['last_observed']}%")
+    console.print(
+        f"  Trend         : "
+        f"[{trend_color}]{result['trend_summary']}[/{trend_color}]"
+    )
+
+    if "components" in result:
+        console.print(
+            f"\n  [dim]ARIMA        : {result['components']['arima']}[/dim]"
+        )
+        console.print(
+            f"  [dim]Holt-Winters : {result['components']['holtwinters']}[/dim]"
+        )
+
+    thresh = METRIC_THRESHOLDS.get(metric, {"warning": 75.0, "critical": 90.0})
+
+    console.print(f"\n  {'Time':>10}   {'Value':>8}   Chart")
+    console.print(f"  {'─'*10}   {'─'*8}   {'─'*20}")
+
+    for i, val in enumerate(result["forecast"], start=1):
+        bar        = "█" * int(val / 5)
+        time_label = steps_to_human_time(i, interval_seconds=interval)
+        col        = _color(val, **thresh)
+        console.print(
+            f"  {time_label:>10} : [{col}]{val:>6.2f}%[/{col}]  {bar}"
+        )
+
+    console.print()
+
+
+@app.command()
+def alert(
+    metric:    str   = typer.Option("cpu_percent", help="Metric to check."),
+    horizon:   str   = typer.Option("30m",         help="How far ahead: '30m', '1h', '2h'."),
+    threshold: float = typer.Option(-1.0,          help="Custom threshold %. Uses smart default if omitted."),
+    model:     str   = typer.Option("ensemble",    help="Model: arima, holtwinters, ensemble."),
+    interval:  int   = typer.Option(60,            help="Your collection interval in seconds."),
+) -> None:
+    """Check if a metric is predicted to breach its health threshold."""
+    init_db()
+
+    if not _validate_inputs(metric, model):
+        raise typer.Exit()
+
+    try:
+        steps = parse_horizon(horizon, interval_seconds=interval)
+    except ValueError as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit()
+
+    # Apply smart default threshold if user didn't provide one
+    if threshold == -1.0:
+        threshold = METRIC_THRESHOLDS.get(
+            metric, {"warning": 85.0}
+        )["warning"]
+        console.print(
+            f"\n  [dim]Using smart default threshold: "
+            f"{threshold}% for {metric}[/dim]"
+        )
+
+    result       = _run_forecast(metric, steps, model)
+    alert_result = check_threshold(forecast_result=result, threshold=threshold)
+
+    status = alert_result["status"]
+    icon   = _status_icon(status)
+    style  = _status_style(status)
+
+    console.print(
+        f"\n  {icon}  [{style}]{status.upper()}[/{style}]"
+        f" — {alert_result['message']}\n"
+    )
+
+    if alert_result["breaches"]:
+        console.print(f"  [dim]Predicted breaches above {threshold}%:[/dim]")
+        for b in alert_result["breaches"]:
+            time_label = steps_to_human_time(b["step"], interval_seconds=interval)
+            console.print(
+                f"    {time_label:>10} : [red]{b['value']}%[/red]"
+            )
+        console.print()
+
+
+@app.command()
+def healthcheck(
+    horizon:  str = typer.Option("30m",      help="How far ahead to check: '30m', '1h', '2h'."),
+    model:    str = typer.Option("ensemble", help="Model: arima, holtwinters, ensemble."),
+    interval: int = typer.Option(60,         help="Your collection interval in seconds."),
+) -> None:
+    """Run a full health check across CPU, RAM, and Disk at once."""
+    init_db()
+
+    if model not in VALID_MODELS:
+        console.print(f"[red]Invalid model. Choose: {', '.join(VALID_MODELS)}[/red]")
+        raise typer.Exit()
+
+    try:
+        steps = parse_horizon(horizon, interval_seconds=interval)
+    except ValueError as e:
+        console.print(f"[red]{e}[/red]")
+        raise typer.Exit()
+
+    metrics_to_check = [
+        ("cpu_percent",  METRIC_THRESHOLDS["cpu_percent"]["warning"]),
+        ("ram_percent",  METRIC_THRESHOLDS["ram_percent"]["warning"]),
+        ("disk_percent", METRIC_THRESHOLDS["disk_percent"]["warning"]),
+    ]
+
+    console.print(
+        f"\n[bold]System Health Check[/bold] — "
+        f"next [cyan]{horizon}[/cyan] "
+        f"via [cyan]{model.upper()}[/cyan]\n"
+    )
+
+    overall_status = "ok"
+
+    for metric, threshold in metrics_to_check:
+        result       = _run_forecast(metric, steps, model)
+        alert_result = check_threshold(forecast_result=result, threshold=threshold)
+        status       = alert_result["status"]
+
+        # Escalate overall only upward: ok → warning → critical
+        if status == "critical":
+            overall_status = "critical"
+        elif status == "warning" and overall_status == "ok":
+            overall_status = "warning"
+
+        icon  = _status_icon(status)
+        style = _status_style(status)
+        col   = _color(
+            result["last_observed"],
+            **METRIC_THRESHOLDS.get(metric, {"warning": 75.0, "critical": 90.0}),
+        )
+
+        console.print(
+            f"  {icon}  [cyan]{metric:<20}[/cyan] "
+            f"[{style}]{status.upper():<10}[/{style}]  "
+            f"now: [{col}]{result['last_observed']}%[/{col}]  "
+            f"threshold: {threshold}%  "
+            f"trend: {result['trend_summary']}"
+        )
+
+    overall_icon  = _status_icon(overall_status)
+    overall_style = _status_style(overall_status)
+
+    console.print(
+        f"\n  {overall_icon}  "
+        f"Overall: [{overall_style}]{overall_status.upper()}[/{overall_style}]\n"
+    )
+
+
+if __name__ == "__main__":
+    app()

foresight_cli-0.1.0/foresight/collector.py

@@ -0,0 +1,50 @@
+import psutil
+from datetime import datetime
+import time
+from foresight.storage import save_snapshot
+
+
+def collect_snapshot() -> dict:
+    cpu = psutil.cpu_percent(interval=1)
+
+    ram = psutil.virtual_memory()
+    ram_used_percent = ram.percent
+    ram_used_mb = ram.used / (1024 ** 2)
+    ram_total_mb = ram.total / (1024 ** 2)
+
+    disk = psutil.disk_usage("/")
+    disk_used_percent = disk.percent
+    disk_used_gb = disk.used / (1024 ** 3)
+    disk_total_gb = disk.total / (1024 ** 3)
+
+    timestamp = datetime.now().isoformat()
+
+    return {
+        "timestamp": timestamp,
+        "cpu_percent": cpu,
+        "ram_percent": ram_used_percent,
+        "ram_used_mb": round(ram_used_mb, 2),
+        "ram_total_mb": round(ram_total_mb, 2),
+        "disk_percent": disk_used_percent,
+        "disk_used_gb": round(disk_used_gb, 2),
+        "disk_total_gb": round(disk_total_gb, 2),
+    }
+
+
+def collect_loop(interval_seconds: int = 60, rounds: int = 60) -> None:
+    print(f"Collecting every {interval_seconds}s for {rounds} rounds...\n")
+    for i in range(rounds):
+        snapshot = collect_snapshot()
+        save_snapshot(snapshot)
+        print(f"[Round {i+1}] {snapshot['timestamp']}")
+        print(f"  CPU  : {snapshot['cpu_percent']}%")
+        print(f"  RAM  : {snapshot['ram_percent']}%  ({snapshot['ram_used_mb']} MB used)")
+        print(f"  Disk : {snapshot['disk_percent']}%  ({snapshot['disk_used_gb']} GB used)\n")
+        if i < rounds - 1:
+            time.sleep(interval_seconds)
+
+
+if __name__ == "__main__":
+    from foresight.storage import init_db
+    init_db()
+    collect_loop(interval_seconds=5, rounds=3)

foresight_cli-0.1.0/foresight/forecaster.py

@@ -0,0 +1,245 @@
+import warnings
+import pandas as pd
+from statsmodels.tsa.arima.model import ARIMA
+from statsmodels.tsa.holtwinters import ExponentialSmoothing
+from foresight.storage import get_metric_series, VALID_METRICS
+
+warnings.filterwarnings("ignore")
+
+MINIMUM_DATA_POINTS = 20
+
+
+# ─── Private Helpers ──────────────────────────────────────────────────────────
+
+def _validate_metric(metric: str) -> None:
+    if metric not in VALID_METRICS:
+        raise ValueError(
+            f"Invalid metric '{metric}'. "
+            f"Choose from: {VALID_METRICS}"
+        )
+
+
+def _load_series(metric: str, limit: int) -> pd.Series:
+    timestamps, values = get_metric_series(metric=metric, limit=limit)
+
+    if len(values) < MINIMUM_DATA_POINTS:
+        raise ValueError(
+            f"Not enough data. Need at least {MINIMUM_DATA_POINTS} "
+            f"snapshots, got {len(values)}. "
+            f"Run 'foresight collect' to gather more data."
+        )
+    # Soft warning — good forecast needs 3x the requested limit
+    if len(values) < limit * 0.5:
+        import warnings
+        warnings.warn(
+            f"Only {len(values)} snapshots available. "
+            f"Forecasts improve significantly with more data. "
+            f"Run 'foresight collect --rounds 60' for best results.",
+            UserWarning,
+            stacklevel=2,
+        )
+
+    return pd.Series(values)
+
+
+def _describe_trend(forecast_values: list[float]) -> str:
+    first = forecast_values[0]
+    last = forecast_values[-1]
+    delta = last - first
+
+    if delta > 5:
+        return "rising"
+    elif delta < -5:
+        return "falling"
+    else:
+        return "stable"
+
+
+# ─── Forecasting Models ───────────────────────────────────────────────────────
+
+def forecast_arima(
+    metric: str = "cpu_percent",
+    steps: int = 10,
+    limit: int = 100,
+    order: tuple = (2, 1, 1),
+) -> dict:
+    _validate_metric(metric)
+    series = _load_series(metric=metric, limit=limit)
+
+    model = ARIMA(series, order=order)
+    fitted = model.fit()
+
+    forecast_result = fitted.forecast(steps=steps)
+    forecast_values = [round(float(v), 2) for v in forecast_result]
+    forecast_values = [max(0.0, min(100.0, v)) for v in forecast_values]
+
+    return {
+        "metric": metric,
+        "model": "ARIMA",
+        "order": order,
+        "last_observed": round(float(series.iloc[-1]), 2),
+        "steps_ahead": steps,
+        "forecast": forecast_values,
+        "trend_summary": _describe_trend(forecast_values),
+    }
+
+
+def forecast_holtwinters(
+    metric: str = "cpu_percent",
+    steps: int = 10,
+    limit: int = 100,
+) -> dict:
+    _validate_metric(metric)
+    series = _load_series(metric=metric, limit=limit)
+
+    model = ExponentialSmoothing(
+        series,
+        trend="add",
+        seasonal=None,
+        initialization_method="estimated",
+    )
+
+    fitted = model.fit(optimized=True)
+    forecast_result = fitted.forecast(steps=steps)
+
+    forecast_values = [
+        round(max(0.0, min(100.0, float(v))), 2)
+        for v in forecast_result
+    ]
+
+    return {
+        "metric": metric,
+        "model": "Holt-Winters",
+        "order": None,
+        "last_observed": round(float(series.iloc[-1]), 2),
+        "steps_ahead": steps,
+        "forecast": forecast_values,
+        "trend_summary": _describe_trend(forecast_values),
+    }
+
+
+def forecast_ensemble(
+    metric: str = "cpu_percent",
+    steps: int = 10,
+    limit: int = 100,
+) -> dict:
+    _validate_metric(metric)
+
+    arima_result = forecast_arima(metric=metric, steps=steps, limit=limit)
+    hw_result = forecast_holtwinters(metric=metric, steps=steps, limit=limit)
+
+    blended = [
+        round(max(0.0, min(100.0, (a + b) / 2)), 2)
+        for a, b in zip(arima_result["forecast"], hw_result["forecast"])
+    ]
+
+    return {
+        "metric": metric,
+        "model": "Ensemble (ARIMA + Holt-Winters)",
+        "order": None,
+        "last_observed": arima_result["last_observed"],
+        "steps_ahead": steps,
+        "forecast": blended,
+        "trend_summary": _describe_trend(blended),
+        "components": {
+            "arima": arima_result["forecast"],
+            "holtwinters": hw_result["forecast"],
+        },
+    }
+
+
+# ─── Alerting ─────────────────────────────────────────────────────────────────
+
+def check_threshold(
+    forecast_result: dict,
+    threshold: float = 85.0,
+) -> dict:
+    forecast_values = forecast_result["forecast"]
+    metric = forecast_result["metric"]
+    last_observed = forecast_result["last_observed"]
+
+    breaches = [
+        {"step": i + 1, "value": v}
+        for i, v in enumerate(forecast_values)
+        if v >= threshold
+    ]
+
+    already_critical = last_observed >= threshold
+
+    if already_critical:
+        status = "critical"
+        message = (
+            f"{metric} is ALREADY at {last_observed}% — "
+            f"above threshold of {threshold}%"
+        )
+    elif breaches:
+        first_breach = breaches[0]
+        status = "warning"
+        message = (
+            f"{metric} predicted to reach {first_breach['value']}% "
+            f"in {steps_to_human_time(first_breach['step'])} "
+            f"(threshold: {threshold}%)"
+        )
+    else:
+        status = "ok"
+        message = (
+            f"{metric} looks safe — "
+            f"no breach predicted within {len(forecast_values)} steps "
+            f"(threshold: {threshold}%)"
+        )
+
+    return {
+        "metric": metric,
+        "threshold": threshold,
+        "status": status,
+        "message": message,
+        "breaches": breaches,
+        "already_critical": already_critical,
+    }
+
+
+# ─── Time Utilities ───────────────────────────────────────────────────────────
+
+def steps_to_human_time(step: int, interval_seconds: int = 60) -> str:
+    total_seconds = step * interval_seconds
+    total_minutes = total_seconds // 60
+
+    if total_minutes < 1:
+        return f"~{total_seconds}s"
+    elif total_minutes < 60:
+        return f"~{total_minutes}m"
+    else:
+        hours = total_minutes // 60
+        minutes = total_minutes % 60
+        if minutes == 0:
+            return f"~{hours}h"
+        return f"~{hours}h {minutes}m"
+
+
+def parse_horizon(horizon: str, interval_seconds: int = 60) -> int:
+    horizon = horizon.strip().lower()
+
+    if horizon.endswith("h"):
+        hours = float(horizon[:-1])
+        total_seconds = hours * 3600
+    elif horizon.endswith("m"):
+        minutes = float(horizon[:-1])
+        total_seconds = minutes * 60
+    else:
+        raise ValueError(
+            f"Invalid horizon '{horizon}'. "
+            f"Use format: '30m' for 30 minutes or '2h' for 2 hours."
+        )
+
+    steps = max(1, int(total_seconds // interval_seconds))
+    return steps
+
+
+if __name__ == "__main__":
+    result = forecast_arima(metric="cpu_percent", steps=10)
+    print(f"\nMetric   : {result['metric']}")
+    print(f"Model    : {result['model']} {result['order']}")
+    print(f"Last seen: {result['last_observed']}%")
+    print(f"Trend    : {result['trend_summary']}")
+    print(f"Forecast : {result['forecast']}")
+

foresight_cli-0.1.0/foresight/storage.py

@@ -0,0 +1,137 @@
+import sqlite3
+from pathlib import Path
+
+
+DB_DIR = Path(__file__).parent.parent / "data"
+DB_PATH = DB_DIR / "foresight.db"
+
+VALID_METRICS = {
+    "cpu_percent",
+    "ram_percent",
+    "ram_used_mb",
+    "disk_percent",
+    "disk_used_gb",
+}
+
+
+def init_db() -> None:
+    DB_DIR.mkdir(parents=True, exist_ok=True)
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS snapshots (
+            id            INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp     TEXT    NOT NULL,
+            cpu_percent   REAL    NOT NULL,
+            ram_percent   REAL    NOT NULL,
+            ram_used_mb   REAL    NOT NULL,
+            ram_total_mb  REAL    NOT NULL,
+            disk_percent  REAL    NOT NULL,
+            disk_used_gb  REAL    NOT NULL,
+            disk_total_gb REAL    NOT NULL
+        )
+    """)
+
+    conn.commit()
+    conn.close()
+
+
+def save_snapshot(snapshot: dict) -> None:
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    cursor.execute("""
+        INSERT INTO snapshots (
+            timestamp,
+            cpu_percent,
+            ram_percent,
+            ram_used_mb,
+            ram_total_mb,
+            disk_percent,
+            disk_used_gb,
+            disk_total_gb
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    """, (
+        snapshot["timestamp"],
+        snapshot["cpu_percent"],
+        snapshot["ram_percent"],
+        snapshot["ram_used_mb"],
+        snapshot["ram_total_mb"],
+        snapshot["disk_percent"],
+        snapshot["disk_used_gb"],
+        snapshot["disk_total_gb"],
+    ))
+
+    conn.commit()
+    conn.close()
+
+
+def get_snapshots(limit: int = 100) -> list[dict]:
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+
+    cursor.execute("""
+        SELECT * FROM snapshots
+        ORDER BY timestamp DESC
+        LIMIT ?
+    """, (limit,))
+
+    rows = cursor.fetchall()
+    conn.close()
+
+    return [dict(row) for row in rows]
+
+
+def get_metric_series(metric: str, limit: int = 50) -> tuple[list, list]:
+    if metric not in VALID_METRICS:
+        raise ValueError(
+            f"Invalid metric '{metric}'. "
+            f"Choose from: {VALID_METRICS}"
+        )
+
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+
+    cursor.execute(f"""
+        SELECT timestamp, {metric}
+        FROM snapshots
+        ORDER BY timestamp DESC
+        LIMIT ?
+    """, (limit,))
+
+    rows = cursor.fetchall()
+    conn.close()
+
+    rows = list(reversed(rows))
+    timestamps = [row["timestamp"] for row in rows]
+    values = [row[metric] for row in rows]
+
+    return timestamps, values
+
+
+if __name__ == "__main__":
+    init_db()
+    print(f"Database initialized at: {DB_PATH}")
+
+    dummy = {
+        "timestamp": "2026-03-22T10:00:00",
+        "cpu_percent": 45.2,
+        "ram_percent": 61.0,
+        "ram_used_mb": 9800.0,
+        "ram_total_mb": 16384.0,
+        "disk_percent": 43.0,
+        "disk_used_gb": 430.0,
+        "disk_total_gb": 953.0,
+    }
+
+    save_snapshot(dummy)
+    print("Saved one dummy snapshot.")
+
+    results = get_snapshots(limit=5)
+    print(f"\nLast {len(results)} snapshots:")
+    for row in results:
+        print(row)

foresight_cli-0.1.0/foresight_cli.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: foresight-cli
+Version: 0.1.0
+Summary: Predict system resource exhaustion before it happens.
+Author: Rishi Garg
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/foresight
+Project-URL: Repository, https://github.com/YOUR_USERNAME/foresight
+Project-URL: Issues, https://github.com/YOUR_USERNAME/foresight/issues
+Keywords: cli,monitoring,forecasting,devops,time-series,arima,machine-learning,psutil,system-monitoring
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: plotext>=5.2.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: statsmodels>=0.14.0

foresight_cli-0.1.0/foresight_cli.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+foresight/__init__.py
+foresight/cli.py
+foresight/collector.py
+foresight/forecaster.py
+foresight/storage.py
+foresight_cli.egg-info/PKG-INFO
+foresight_cli.egg-info/SOURCES.txt
+foresight_cli.egg-info/dependency_links.txt
+foresight_cli.egg-info/entry_points.txt
+foresight_cli.egg-info/requires.txt
+foresight_cli.egg-info/top_level.txt

foresight_cli-0.1.0/foresight_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

foresight_cli-0.1.0/foresight_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+foresight = foresight.cli:app

foresight_cli-0.1.0/foresight_cli.egg-info/requires.txt

@@ -0,0 +1,6 @@
+psutil>=5.9.0
+rich>=13.0.0
+typer>=0.9.0
+plotext>=5.2.0
+pandas>=2.0.0
+statsmodels>=0.14.0

foresight_cli-0.1.0/foresight_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+foresight

foresight_cli-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["setuptools>=65", "wheel"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "foresight-cli"
+version = "0.1.0"
+description = "Predict system resource exhaustion before it happens."
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.10"
+authors = [
+    { name = "Rishi Garg" }
+]
+keywords = [
+    "cli", "monitoring", "forecasting", "devops",
+    "time-series", "arima", "machine-learning",
+    "psutil", "system-monitoring"
+]
+classifiers = [
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: System :: Monitoring",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+]
+dependencies = [
+    "psutil>=5.9.0",
+    "rich>=13.0.0",
+    "typer>=0.9.0",
+    "plotext>=5.2.0",
+    "pandas>=2.0.0",
+    "statsmodels>=0.14.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/YOUR_USERNAME/foresight"
+Repository = "https://github.com/YOUR_USERNAME/foresight"
+Issues = "https://github.com/YOUR_USERNAME/foresight/issues"
+
+[project.scripts]
+foresight = "foresight.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["foresight*"]
+

foresight_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+