nikofetch 0.1.0__tar.gz

nikofetch-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nikohalfkino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nikofetch-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: nikofetch
+Version: 0.1.0
+Summary: A tiny fastfetch-style system info banner
+Author: niko
+License: MIT
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/nikofetch
+Project-URL: Issues, https://github.com/YOUR_USERNAME/nikofetch/issues
+Keywords: fetch,fastfetch,neofetch,system-info,cli,terminal
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Terminals
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.9
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+# nikofetch
+
+A tiny fastfetch-style system info banner, written in Python.
+
+```
+you@host                                    Sat Jan 01, 12:00
+
+  OS:       Linux 6.x
+  Kernel:   6.x
+  Shell:    zsh
+  Terminal: kitty
+  Uptime:   2d 4h 12m
+  CPU:      12% @ 3.60 GHz
+  Memory:   8.2 GiB / 32.0 GiB (26%)
+  Disk:     120 GiB / 512 GiB (23%)
+```
+
+## Features
+
+- Minimal, configurable stat banner (OS, kernel, shell, terminal, uptime, CPU, memory, disk)
+- Customizable titlebar with `{user}`, `{host}`, `{date}`, `{time}` placeholders
+- Optional ASCII art or (in [kitty](https://sw.kovidgoyal.net/kitty/)) inline image art
+- Interactive terminal config menu — no need to hand-edit JSON
+
+## Install
+
+```bash
+pipx install nikofetch
+```
+
+or
+
+```bash
+pip install nikofetch
+```
+
+## Usage
+
+```bash
+nikofetch            # show the banner
+nikofetch --config   # open the interactive config menu
+```
+
+Config is stored at `~/.config/nikofetch/config.json`.
+
+## Development
+
+```bash
+git clone https://github.com/YOUR_USERNAME/nikofetch
+cd nikofetch
+pip install -e .
+```
+
+## License
+
+MIT

nikofetch-0.1.0/README.md

@@ -0,0 +1,56 @@
+# nikofetch
+
+A tiny fastfetch-style system info banner, written in Python.
+
+```
+you@host                                    Sat Jan 01, 12:00
+
+  OS:       Linux 6.x
+  Kernel:   6.x
+  Shell:    zsh
+  Terminal: kitty
+  Uptime:   2d 4h 12m
+  CPU:      12% @ 3.60 GHz
+  Memory:   8.2 GiB / 32.0 GiB (26%)
+  Disk:     120 GiB / 512 GiB (23%)
+```
+
+## Features
+
+- Minimal, configurable stat banner (OS, kernel, shell, terminal, uptime, CPU, memory, disk)
+- Customizable titlebar with `{user}`, `{host}`, `{date}`, `{time}` placeholders
+- Optional ASCII art or (in [kitty](https://sw.kovidgoyal.net/kitty/)) inline image art
+- Interactive terminal config menu — no need to hand-edit JSON
+
+## Install
+
+```bash
+pipx install nikofetch
+```
+
+or
+
+```bash
+pip install nikofetch
+```
+
+## Usage
+
+```bash
+nikofetch            # show the banner
+nikofetch --config   # open the interactive config menu
+```
+
+Config is stored at `~/.config/nikofetch/config.json`.
+
+## Development
+
+```bash
+git clone https://github.com/YOUR_USERNAME/nikofetch
+cd nikofetch
+pip install -e .
+```
+
+## License
+
+MIT

nikofetch-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nikofetch"
+version = "0.1.0"
+description = "A tiny fastfetch-style system info banner"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [
+    { name = "niko" }  # <-- put your name / GitHub handle here
+]
+keywords = ["fetch", "fastfetch", "neofetch", "system-info", "cli", "terminal"]
+classifiers = [
+    "Environment :: Console",
+    "Intended Audience :: End Users/Desktop",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Topic :: Terminals",
+]
+dependencies = [
+    "psutil>=5.9",
+    "rich>=13.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/YOUR_USERNAME/nikofetch"
+Issues = "https://github.com/YOUR_USERNAME/nikofetch/issues"
+
+[project.scripts]
+nikofetch = "nikofetch:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

nikofetch-0.1.0/setup.cfg

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

nikofetch-0.1.0/src/nikofetch/__init__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+__all__ = ["main"]
+__version__ = "0.1.0"

nikofetch-0.1.0/src/nikofetch/cli.py

@@ -0,0 +1,531 @@
+#!/usr/bin/env python3
+"""
+nikofetch - a tiny fastfetch-style system info banner
+
+Usage:
+    nikofetch            # display current banner
+    nikofetch --config   # config menu
+"""
+
+import argparse
+import contextlib
+import copy
+import curses
+import getpass
+import json
+import os
+import platform
+import re
+import shutil
+import socket
+import subprocess
+import sys
+import termios
+import tty
+from datetime import datetime
+from pathlib import Path
+
+import psutil
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+console = Console()
+
+CONFIG_DIR = Path.home() / ".config" / "nikofetch"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+
+DEFAULT_CONFIG = {
+    "titlebar": {
+        "left": "{user}@{host}",
+        "center": "",
+        "right": "{date}, {time}",
+    },
+    "stats": {
+        "os": True,
+        "kernel": True,
+        "shell": True,
+        "terminal": True,
+        "uptime": True,
+        "cpu": True,
+        "memory": True,
+        "disk": True,
+    },
+    "art": {
+        "mode": "none",  # none | ascii | image
+        "ascii_path": "",
+        "image_path": "",
+    },
+}
+
+
+ 
+# Config load/save
+ 
+
+def load_config() -> dict:
+    if not CONFIG_PATH.exists():
+        return copy.deepcopy(DEFAULT_CONFIG)
+    try:
+        with open(CONFIG_PATH) as f:
+            loaded = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return copy.deepcopy(DEFAULT_CONFIG)
+
+    # merge with defaults so new keys added in future versions don't break old configs
+    merged = copy.deepcopy(DEFAULT_CONFIG)
+    for section, values in loaded.items():
+        if section in merged and isinstance(values, dict):
+            merged[section].update(values)
+        else:
+            merged[section] = values
+    return merged
+
+
+def save_config(config: dict):
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_PATH, "w") as f:
+        json.dump(config, f, indent=2)
+
+
+ 
+# Stat getters
+ 
+
+def get_uptime() -> str:
+    boot = datetime.fromtimestamp(psutil.boot_time())
+    delta = datetime.now() - boot
+    days, rem = divmod(int(delta.total_seconds()), 86400)
+    hours, rem = divmod(rem, 3600)
+    minutes, _ = divmod(rem, 60)
+    parts = []
+    if days:
+        parts.append(f"{days}d")
+    if hours:
+        parts.append(f"{hours}h")
+    parts.append(f"{minutes}m")
+    return " ".join(parts)
+
+
+def get_shell() -> str:
+    shell_path = os.environ.get("SHELL", "unknown")
+    return shell_path.split("/")[-1]
+
+
+def get_terminal() -> str:
+    return os.environ.get("TERM_PROGRAM") or os.environ.get("TERM", "unknown")
+
+
+def get_memory() -> str:
+    vm = psutil.virtual_memory()
+    used_gb = vm.used / (1024 ** 3)
+    total_gb = vm.total / (1024 ** 3)
+    return f"{used_gb:.1f} GiB / {total_gb:.1f} GiB ({vm.percent}%)"
+
+
+def get_cpu() -> str:
+    freq = psutil.cpu_freq()
+    # interval=None measures since the last call, so this reads 0% on a
+    # fresh process (e.g. a one-shot `nikofetch` run). Pass a small
+    # interval (e.g. 0.1) if accuracy matters more than startup latency.
+    load = psutil.cpu_percent(interval=None)
+    if freq:
+        return f"{load:.0f}% @ {freq.current / 1000:.2f} GHz"
+    return f"{load:.0f}%"
+
+
+def get_disk() -> str:
+    du = psutil.disk_usage("/")
+    used_gb = du.used / (1024 ** 3)
+    total_gb = du.total / (1024 ** 3)
+    return f"{used_gb:.0f} GiB / {total_gb:.0f} GiB ({du.percent}%)"
+
+
+STAT_DEFINITIONS = [
+    ("os", "OS", lambda: f"{platform.system()} {platform.release()}"),
+    ("kernel", "Kernel", lambda: platform.version().split()[0] if platform.version() else "n/a"),
+    ("shell", "Shell", get_shell),
+    ("terminal", "Terminal", get_terminal),
+    ("uptime", "Uptime", get_uptime),
+    ("cpu", "CPU", get_cpu),
+    ("memory", "Memory", get_memory),
+    ("disk", "Disk", get_disk),
+]
+
+
+
+# Rendering
+
+
+def format_placeholders(text: str) -> str:
+    now = datetime.now()
+    return text.format(
+        user=getpass.getuser(),
+        host=socket.gethostname(),
+        date=now.strftime("%a %b %d"),
+        time=now.strftime("%H:%M"),
+    )
+
+
+def build_titlebar(config: dict, width: int) -> Text:
+    left = format_placeholders(config["titlebar"].get("left", "")).strip()
+    center = format_placeholders(config["titlebar"].get("center", "")).strip()
+    right = format_placeholders(config["titlebar"].get("right", "")).strip()
+
+    left = f" {left} " if left else ""
+    right = f" {right} " if right else ""
+    center = f" {center} " if center else ""
+
+    remaining = width - len(left) - len(right)
+
+    if center and remaining > len(center):
+        gap = remaining - len(center)
+        left_pad = gap // 2
+        right_pad = gap - left_pad
+        bar_text = f"{left}{' ' * left_pad}{center}{' ' * right_pad}{right}"
+    else:
+        pad = max(remaining, 0)
+        bar_text = f"{left}{' ' * pad}{right}"
+
+    bar_text = bar_text[:width] if width else bar_text
+    return Text(bar_text, style="black on white")
+
+
+def build_stats_table(config: dict) -> Table:
+    table = Table.grid(padding=(0, 2))
+    table.add_column(justify="right", style="bold cyan")
+    table.add_column()
+
+    for key, label, getter in STAT_DEFINITIONS:
+        if config["stats"].get(key, True):
+            table.add_row(f"{label}:", getter())
+    return table
+
+
+def load_ascii_art(config: dict) -> str | None:
+    art = config.get("art", {})
+    if art.get("mode") != "ascii" or not art.get("ascii_path"):
+        return None
+    resolved = Path(art["ascii_path"]).expanduser()
+    if not resolved.exists():
+        console.print(f"[red]ASCII art file not found: {art['ascii_path']}[/red]")
+        return None
+    try:
+        return resolved.read_text()
+    except OSError as e:
+        console.print(f"[red]Couldn't read ASCII art file: {e}[/red]")
+        return None
+
+
+IMAGE_WIDTH_CELLS = 22  # how much horizontal space to reserve for the image
+
+
+@contextlib.contextmanager
+def raw_terminal():
+    # puts stdin into raw mode for the block, restoring old settings after
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        yield fd
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+
+def _query_cursor_row() -> int:
+    with raw_terminal():
+        sys.stdout.write("\x1b[6n")
+        sys.stdout.flush()
+        buf = ""
+        while "R" not in buf:
+            buf += sys.stdin.read(1)
+    match = re.search(r"\x1b\[(\d+);(\d+)R", buf)
+    return int(match.group(1)) if match else 1
+
+
+def render_image_beside_stats(config: dict, stats_table: Table) -> bool:
+    """Place the configured image at the cursor's current row using kitty's
+    --place (absolute screen coordinates), then manually cursor-position each
+    stats line to sit beside it. Returns True if it handled the image (even
+    if it fell back to printing an error), False if there's nothing to do."""
+    art = config.get("art", {})
+    if art.get("mode") != "image" or not art.get("image_path"):
+        return False
+
+    image_path = art["image_path"]
+    if "KITTY_WINDOW_ID" not in os.environ:
+        console.print(
+            "[yellow]Image art configured, but this isn't a kitty terminal — skipping.[/yellow]"
+        )
+        return False
+    resolved = Path(image_path).expanduser()
+    if not resolved.exists():
+        console.print(f"[red]Image not found: {image_path}[/red]")
+        return False
+    if not shutil.which("kitten"):
+        console.print("[yellow]'kitten' command not found — can't display image.[/yellow]")
+        return False
+
+    with console.capture() as capture:
+        console.print(stats_table)
+    lines = capture.get().rstrip("\n").split("\n")
+
+    image_height = max(len(lines), 6)
+    row = _query_cursor_row()
+    top = row - 1  # --place uses 0-indexed screen coordinates
+
+    subprocess.run(
+        [
+            "kitten", "icat",
+            f"--place={IMAGE_WIDTH_CELLS}x{image_height}@0x{top}",
+            "--align=left",
+            "--scale-up",
+            str(resolved),
+        ]
+    )
+
+    gap = 2
+    text_col = IMAGE_WIDTH_CELLS + gap
+    for i, line in enumerate(lines):
+        sys.stdout.write(f"\x1b[{top + i + 1};{text_col + 1}H{line}")
+    sys.stdout.flush()
+
+    final_row = top + max(image_height, len(lines)) + 1
+    sys.stdout.write(f"\x1b[{final_row};1H\n")
+    sys.stdout.flush()
+    return True
+
+
+def render_once(config: dict | None = None):
+    if config is None:
+        config = load_config()
+    width = console.size.width
+
+    console.print(build_titlebar(config, width))
+    console.print()
+
+    ascii_text = load_ascii_art(config)
+    stats_table = build_stats_table(config)
+
+    if render_image_beside_stats(config, stats_table):
+        pass  # image handled its own placement, including the stats table
+    elif ascii_text:
+        combined = Table.grid(padding=(0, 4))
+        combined.add_column()
+        combined.add_column()
+        combined.add_row(Text(ascii_text, style="bold"), stats_table)
+        console.print(combined)
+    else:
+        console.print(stats_table)
+
+    console.print()
+
+
+
+# config menu 
+
+HELP_SELECT = "Arrows: move   Z: select   X: back"
+HELP_CHECKBOX = "Arrows: move   Z: toggle   X: back/done"
+HELP_TEXT = "Type to edit   Enter: confirm   Backspace: delete"
+
+
+def _addstr_safe(stdscr, y, x, text, attr=curses.A_NORMAL):
+    height, width = stdscr.getmaxyx()
+    if 0 <= y < height and x < width:
+        try:
+            stdscr.addstr(y, x, text[: max(width - x - 1, 0)], attr)
+        except curses.error:
+            pass
+
+
+def _curses_menu_loop(stdscr, title: str, n: int, render_row, on_select, help_text: str):
+    """Shared arrow-key menu loop used by curses_select and curses_checkbox.
+    render_row(i, selected) -> str for row i.
+    on_select(i) runs on Z; return True to exit the loop, False to keep it open.
+    Returns the selected index, or None if X was pressed."""
+    idx = 0
+    while True:
+        stdscr.clear()
+        _addstr_safe(stdscr, 0, 0, title, curses.A_BOLD)
+        for i in range(n):
+            attr = curses.A_REVERSE if i == idx else curses.A_NORMAL
+            _addstr_safe(stdscr, 2 + i, 0, render_row(i, i == idx), attr)
+        _addstr_safe(stdscr, 3 + n, 0, help_text, curses.A_DIM)
+        stdscr.refresh()
+
+        key = stdscr.getch()
+        if key == curses.KEY_UP:
+            idx = (idx - 1) % n
+        elif key == curses.KEY_DOWN:
+            idx = (idx + 1) % n
+        elif key in (ord("z"), ord("Z")):
+            if on_select(idx):
+                return idx
+        elif key in (ord("x"), ord("X")):
+            return None
+
+
+def curses_select(stdscr, title: str, choices: list) -> str | None:
+    """choices: list of (label, value)"""
+
+    def render_row(i, selected):
+        prefix = "> " if selected else "  "
+        return f"{prefix}{choices[i][0]}"
+
+    idx = _curses_menu_loop(stdscr, title, len(choices), render_row, lambda i: True, HELP_SELECT)
+    return choices[idx][1] if idx is not None else None
+
+
+def curses_checkbox(stdscr, title: str, config: dict):
+    def render_row(i, selected):
+        key, label, _getter = STAT_DEFINITIONS[i]
+        checked = config["stats"].get(key, True)
+        box = "[X]" if checked else "[ ]"
+        prefix = "> " if selected else "  "
+        return f"{prefix}{box} {label}"
+
+    def toggle(i):
+        stat_key = STAT_DEFINITIONS[i][0]
+        config["stats"][stat_key] = not config["stats"].get(stat_key, True)
+        return False  # X exits this menu, not Z
+
+    _curses_menu_loop(stdscr, title, len(STAT_DEFINITIONS), render_row, toggle, HELP_CHECKBOX)
+
+
+def curses_text_input(stdscr, title: str, default: str = "", footer: str | None = None) -> str:
+    curses.curs_set(1)
+    buf = list(default)
+    pos = len(buf)
+    try:
+        while True:
+            stdscr.clear()
+            _addstr_safe(stdscr, 0, 0, title, curses.A_BOLD)
+            _addstr_safe(stdscr, 2, 0, "".join(buf))
+            if footer:
+                _addstr_safe(stdscr, 4, 0, footer, curses.A_DIM)
+                _addstr_safe(stdscr, 5, 0, HELP_TEXT, curses.A_DIM)
+            else:
+                _addstr_safe(stdscr, 4, 0, HELP_TEXT, curses.A_DIM)
+            stdscr.move(2, min(pos, stdscr.getmaxyx()[1] - 1))
+            stdscr.refresh()
+
+            key = stdscr.getch()
+            if key in (curses.KEY_ENTER, 10, 13):
+                return "".join(buf)
+            elif key in (curses.KEY_BACKSPACE, 127, 8):
+                if pos > 0:
+                    buf.pop(pos - 1)
+                    pos -= 1
+            elif key == curses.KEY_LEFT:
+                pos = max(0, pos - 1)
+            elif key == curses.KEY_RIGHT:
+                pos = min(len(buf), pos + 1)
+            elif 32 <= key <= 126:
+                buf.insert(pos, chr(key))
+                pos += 1
+    finally:
+        curses.curs_set(0)
+
+
+def curses_preview(stdscr, config: dict):
+    curses.def_prog_mode()
+    curses.endwin()
+    console.clear()
+    render_once(config)
+    console.print("[dim]Press Enter or Space to return...[/dim]")
+
+    with raw_terminal():
+        while True:
+            ch = sys.stdin.read(1)
+            if ch in ("\r", "\n", " "):
+                break
+
+    console.clear()
+    curses.reset_prog_mode()
+    stdscr.clear()
+    stdscr.refresh()
+
+
+def _config_menu_titlebar(stdscr, config: dict):
+    placeholders_note = "Placeholders: {user} {host} {date} {time}"
+    config["titlebar"]["left"] = curses_text_input(
+        stdscr, "Left text:", config["titlebar"].get("left", ""), footer=placeholders_note
+    )
+    config["titlebar"]["center"] = curses_text_input(
+        stdscr, "Center text (blank for none):", config["titlebar"].get("center", ""), footer=placeholders_note
+    )
+    config["titlebar"]["right"] = curses_text_input(
+        stdscr, "Right text:", config["titlebar"].get("right", ""), footer=placeholders_note
+    )
+
+
+def _config_menu_art(stdscr, config: dict):
+    mode = curses_select(
+        stdscr,
+        "Banner art:",
+        [("None", "none"), ("ASCII art (from a .txt file)", "ascii"), ("Image (kitty terminal only)", "image")],
+    )
+    if mode is None:
+        return
+    config["art"]["mode"] = mode
+
+    if mode == "ascii":
+        path = curses_text_input(
+            stdscr, "Path to .txt file with ASCII art:", config["art"].get("ascii_path", "")
+        )
+        config["art"]["ascii_path"] = path
+    elif mode == "image":
+        config["art"]["image_path"] = curses_text_input(
+            stdscr, "Path to image file:", config["art"].get("image_path", "")
+        )
+
+
+def _run_config_menu(stdscr, config: dict):
+    curses.curs_set(0)
+    while True:
+        action = curses_select(
+            stdscr,
+            "nikofetch config",
+            [
+                ("Toggle stats", "stats"),
+                ("Edit titlebar text", "titlebar"),
+                ("Set banner art (ascii / image / none)", "art"),
+                ("Preview", "preview"),
+                ("Save and exit", "save"),
+                ("Exit without saving", "exit"),
+            ],
+        )
+        if action is None or action == "exit":
+            return
+        elif action == "stats":
+            curses_checkbox(stdscr, "Toggle stats", config)
+        elif action == "titlebar":
+            _config_menu_titlebar(stdscr, config)
+        elif action == "art":
+            _config_menu_art(stdscr, config)
+        elif action == "preview":
+            curses_preview(stdscr, config)
+        elif action == "save":
+            save_config(config)
+            return
+
+
+def run_config_menu():
+    config = load_config()
+    curses.wrapper(_run_config_menu, config)
+
+# Entry point
+ 
+def main():
+    parser = argparse.ArgumentParser(description="nikofetch - minimal system info banner")
+    parser.add_argument("--config", action="store_true", help="open the interactive config menu")
+    args = parser.parse_args()
+
+    if args.config:
+        run_config_menu()
+    else:
+        render_once()
+
+
+if __name__ == "__main__":
+    main()

nikofetch-0.1.0/src/nikofetch.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: nikofetch
+Version: 0.1.0
+Summary: A tiny fastfetch-style system info banner
+Author: niko
+License: MIT
+Project-URL: Homepage, https://github.com/YOUR_USERNAME/nikofetch
+Project-URL: Issues, https://github.com/YOUR_USERNAME/nikofetch/issues
+Keywords: fetch,fastfetch,neofetch,system-info,cli,terminal
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Terminals
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.9
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+# nikofetch
+
+A tiny fastfetch-style system info banner, written in Python.
+
+```
+you@host                                    Sat Jan 01, 12:00
+
+  OS:       Linux 6.x
+  Kernel:   6.x
+  Shell:    zsh
+  Terminal: kitty
+  Uptime:   2d 4h 12m
+  CPU:      12% @ 3.60 GHz
+  Memory:   8.2 GiB / 32.0 GiB (26%)
+  Disk:     120 GiB / 512 GiB (23%)
+```
+
+## Features
+
+- Minimal, configurable stat banner (OS, kernel, shell, terminal, uptime, CPU, memory, disk)
+- Customizable titlebar with `{user}`, `{host}`, `{date}`, `{time}` placeholders
+- Optional ASCII art or (in [kitty](https://sw.kovidgoyal.net/kitty/)) inline image art
+- Interactive terminal config menu — no need to hand-edit JSON
+
+## Install
+
+```bash
+pipx install nikofetch
+```
+
+or
+
+```bash
+pip install nikofetch
+```
+
+## Usage
+
+```bash
+nikofetch            # show the banner
+nikofetch --config   # open the interactive config menu
+```
+
+Config is stored at `~/.config/nikofetch/config.json`.
+
+## Development
+
+```bash
+git clone https://github.com/YOUR_USERNAME/nikofetch
+cd nikofetch
+pip install -e .
+```
+
+## License
+
+MIT

nikofetch-0.1.0/src/nikofetch.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/nikofetch/__init__.py
+src/nikofetch/cli.py
+src/nikofetch.egg-info/PKG-INFO
+src/nikofetch.egg-info/SOURCES.txt
+src/nikofetch.egg-info/dependency_links.txt
+src/nikofetch.egg-info/entry_points.txt
+src/nikofetch.egg-info/requires.txt
+src/nikofetch.egg-info/top_level.txt

nikofetch-0.1.0/src/nikofetch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nikofetch-0.1.0/src/nikofetch.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nikofetch = nikofetch:main

nikofetch-0.1.0/src/nikofetch.egg-info/requires.txt

@@ -0,0 +1,2 @@
+psutil>=5.9
+rich>=13.0

nikofetch-0.1.0/src/nikofetch.egg-info/top_level.txt

@@ -0,0 +1 @@
+nikofetch