update for manually running workflow for old releases

i hate llms so much

.github/workflows/build-and-release.yml

@@ -0,0 +1,80 @@
+name: Build and Release
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "v*"
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        description: "Optional tag to release (e.g. v1.1)"
+        required: false
+        type: string
+
+jobs:
+  build:
+    if: github.event_name == 'pull_request' || github.ref == 'refs/heads/main' || github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    container: debian:11
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install build dependencies
+        run: apt-get update && apt-get install -y --no-install-recommends make g++ git tar ca-certificates
+
+      - name: Build
+        run: make clean build
+
+  release:
+    if: (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')) || (github.event_name == 'workflow_dispatch' && inputs.release_tag != '')
+    runs-on: ubuntu-latest
+    container: debian:11
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout (tag push)
+        uses: actions/checkout@v4
+        if: github.event_name == 'push'
+
+      - name: Checkout (manual tag)
+        uses: actions/checkout@v4
+        if: github.event_name == 'workflow_dispatch'
+        with:
+          ref: ${{ inputs.release_tag }}
+
+      - name: Install build dependencies
+        run: apt-get update && apt-get install -y --no-install-recommends make g++ git tar ca-certificates
+
+      - name: Build release tarball
+        env:
+          VERSION: ${{ github.event_name == 'workflow_dispatch' && inputs.release_tag || github.ref_name }}
+        run: |
+          if make -n release >/dev/null 2>&1; then
+            make release VERSION="$VERSION"
+          else
+            make clean build
+            mkdir -p dist
+            tar -C build -czf "dist/fetchit-${VERSION}-linux-x86_64-gnu.tar.gz" fetchit
+          fi
+
+      - name: Upload workflow artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: fetchit-${{ github.event_name == 'workflow_dispatch' && inputs.release_tag || github.ref_name }}-linux-x86_64-gnu
+          path: dist/*.tar.gz
+
+      - name: Publish GitHub release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ github.event_name == 'workflow_dispatch' && inputs.release_tag || github.ref_name }}
+          files: dist/*.tar.gz
+          overwrite_files: true
+          generate_release_notes: true

.gitignore

@@ -1,69 +1,6 @@
-# Prerequisites
-*.d
-
-# Compiled Object files
-*.slo
-*.lo
-*.o
-*.obj
-
-# Precompiled Headers
-*.gch
-*.pch
-
-# Linker files
-*.ilk
-
-# Debugger Files
-*.pdb
-
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-*.so.*
-
-
-# Fortran module files
-*.mod
-*.smod
-
-# Compiled Static libraries
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables
-*.exe
-*.out
-*.app
-
 # Build directories
 build/
 Build/
 build-*/
+dist/
 
-# CMake generated files
-CMakeFiles/
-CMakeCache.txt
-cmake_install.cmake
-Makefile
-install_manifest.txt
-compile_commands.json
-
-# Temporary files
-*.tmp
-*.log
-*.bak
-*.swp
-
-# vcpkg
-vcpkg_installed/
-
-# debug information files
-*.dwo
-
-# test output & cache
-Testing/
-.cache/

Makefile

@@ -0,0 +1,50 @@
+APP := fetchit
+SRC := main.cpp
+BUILD_DIR := build
+DIST_DIR := dist
+
+PREFIX ?= /usr/local
+BINDIR ?= $(PREFIX)/bin
+DESTDIR ?=
+
+CXX ?= g++
+CXXFLAGS ?= -O2 -Wall -Wextra -std=c++17 -pipe
+LDFLAGS ?= -static-libstdc++ -static-libgcc
+
+VERSION ?= $(shell git describe --tags --dirty --always 2>/dev/null)
+
+.PHONY: all build run install uninstall clean dist release
+
+all: build
+
+build: $(BUILD_DIR)/$(APP)
+
+$(BUILD_DIR)/$(APP): $(SRC) | $(BUILD_DIR)/.dir
+	$(CXX) $(CXXFLAGS) -o $@ $< $(LDFLAGS)
+
+
+$(BUILD_DIR)/.dir:
+	mkdir -p $(BUILD_DIR)
+	touch $@
+
+run: build
+	./$(BUILD_DIR)/$(APP)
+
+install: build
+	install -d "$(DESTDIR)$(BINDIR)"
+	install -m 0755 $(BUILD_DIR)/$(APP) "$(DESTDIR)$(BINDIR)/$(APP)"
+
+uninstall:
+	rm -f "$(DESTDIR)$(BINDIR)/$(APP)"
+
+clean:
+	rm -f $(BUILD_DIR)/$(APP)
+
+dist: build | $(DIST_DIR)/.dir
+	tar -C $(BUILD_DIR) -czf $(DIST_DIR)/$(APP)-$(VERSION)-linux-x86_64-gnu.tar.gz $(APP)
+
+$(DIST_DIR)/.dir:
+	mkdir -p $(DIST_DIR)
+	touch $@
+
+release: clean build dist

README.md

@@ -1,2 +1,64 @@
 # fetchit
-Works on my machine
+
+fetchit is a terminal-based system information viewer written in C++. It works like neofetch/fastfetch and consists of a single file (`main.cpp`).
+
+## Features
+
+- Displays distro, kernel, uptime, shell, CPU, GPU, RAM, and OS date information.
+- Detects distro name via `/etc/os-release`.
+- Shows ASCII logos for supported distros.
+- Reads `/usr/share/hwdata/pci.ids` for GPU names; prints hex IDs if missing.
+- Accounts for Unicode character width (for icon alignment).
+
+## Supported Distro Logos
+
+`arch`, `cachyos`, `debian`, `ubuntu`, `fedora`, `manjaro`, `opensuse`, `pop`, `linuxmint`, `endeavouros`, `void`, `alpine`
+
+## Requirements
+
+- Linux
+- A C++17-capable compiler (e.g., g++)
+- A UTF-8 terminal with ANSI color support (for icons and colors)
+- The following files/paths are read:
+  - `/etc/os-release`
+  - `/etc/hostname`
+  - `/proc/uptime`
+  - `/proc/cpuinfo`
+  - `/proc/meminfo`
+  - `/sys/bus/pci/devices/`
+  - `/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq`
+  - `/usr/share/hwdata/pci.ids` (optional)
+
+## Build
+
+```bash
+g++ -std=c++17 -O2 -o fetchit main.cpp
+```
+
+## Run
+
+```bash
+./fetchit
+```
+
+## Sample Output
+
+```text
+                              --- murat@baklava ---
+
+       /\           distro:     Arch Linux
+      /  \          kernel:     7.0.10-arch1-1
+     /    \         uptime:     1 minutes
+    /      \        shell:      /usr/bin/bash
+   /   ,,   \      󰍛 CPU:        12th Gen Intel(R) Core(TM) i5-12500H (16) @ 4.5 GHz
+  /   |  |   \     󰾲 GPU:        AD107M [GeForce RTX 4060 Max-Q / Mobile] / Alder Lake-P GT2 [Iris Xe Graphics]
+ /_-''    ''-_\     RAM:        15.2529 GB
+                    OS Date:    6 months 17 days 3 hours 40 minutes
+```
+
+## Notes
+
+- `OS Date` is based on the creation time of `/etc/hostname`.
+- If no ASCII logo is found, only the info list is printed.
+- The distro logo is displayed in color via ANSI escape codes.
+- This tool targets Linux systems and is not expected to work on non-Linux OSes.

main.cpp

@@ -3,6 +3,7 @@
 #include <filesystem>
 #include <iostream>
 #include <vector>
+#include <array>
 #include <string>
 #include <sstream>
 #include <unordered_map>
@@ -10,6 +11,8 @@
 #include <sys/utsname.h>
 #include <sys/stat.h>
 #include <ctime>
+#include <clocale>
+#include <cwchar>
 
 using std::string, std::cout;
 namespace fs = std::filesystem;
@@ -17,6 +20,7 @@ namespace fs = std::filesystem;
 string getUser();
 string getHost();
 string getDistro();
+std::vector<string> distroArt();
 string getKernel();
 string getUptime();
 string getShell();
@@ -25,6 +29,39 @@ string getGPU();
 string getRAM();
 string getOsDate();
 
+enum class Color {
+    Red,
+    RedLight,
+    RedDeep,
+    Green,
+    GreenLight,
+    GreenDeep,
+    Blue,
+    BlueLight,
+    BlueDeep,
+    Yellow,
+    YellowLight,
+    Magenta,
+    Purple,
+    PurpleLight,
+    PurpleDeep,
+    Orange,
+    OrangeLight,
+    OrangeDeep,
+    Cyan,
+    Gray,
+    Dark,
+    Reset
+};
+
+string color(Color c);
+
+struct DistroLogo {
+    string id;
+    Color color;
+    std::array<string, 8> art;
+};
+
 struct gpuId {
     string vendor;
     string device;
@@ -50,23 +87,85 @@ std::vector<gpuId> getGpuIds() {
     return gpus;
 }
 
-int main (int argc, const char *argv[]) {
-    const string colorRED = "\033[1;31m";
-    const string colorGREEN = "\033[1;32m";
-    const string colorBLUE = "\033[1;34m";
-    const string colorYELLOW = "\033[1;33m";
-    const string colorMAGENTA = "\033[1;35m";
-    const string colorRESET = "\033[0m";
+int main () {
+    std::setlocale(LC_ALL, "");
 
-    cout << "\t\t\t--- " << colorGREEN << getUser() << colorRESET << "@" << colorRED << getHost() << colorRESET << " ---\n";
-    cout << colorGREEN << "\t\t distro:\t" << colorRESET << getDistro() << "\n";
-    cout << colorMAGENTA << "\t\t kernel:\t" << colorRESET << getKernel() << "\n";
-    cout << colorBLUE << "\t\t uptime:\t" << colorRESET << getUptime() << "\n";
-    cout << colorMAGENTA << "\t\t shell:\t" << colorRESET << getShell() << "\n";
-    cout << colorYELLOW <<"\t\t󰍛 CPU:  \t" << colorRESET << getCPU() << "\n";
-    cout << colorYELLOW <<"\t\t󰾲 GPU:  \t" << colorRESET << getGPU() << "\n";
-    cout << colorRED << "\t\t RAM:  \t" << colorRESET << getRAM() << "\n";
-    cout << colorBLUE << "\t\t OS Date:\t" << colorRESET << getOsDate() << "\n";
+    auto displayWidth = [&](const string& text) {
+        std::mbstate_t state{};
+        const char* src = text.c_str();
+        size_t len = std::mbsrtowcs(nullptr, &src, 0, &state);
+        if (len == static_cast<size_t>(-1)) {
+            return static_cast<int>(text.size());
+        }
+        std::wstring wide(len, L'\0');
+        state = std::mbstate_t{};
+        src = text.c_str();
+        std::mbsrtowcs(wide.data(), &src, len, &state);
+
+        int width = 0;
+        for (wchar_t ch : wide) {
+            int w = wcwidth(ch);
+            if (w > 0) width += w;
+        }
+        return width;
+    };
+
+    auto formatLine = [&](Color c, const string& label, const string& value) {
+        const size_t labelWidth = 12;
+        const size_t valueGap = 2;
+        string padded = label;
+        int currentWidth = displayWidth(padded);
+        if (currentWidth < static_cast<int>(labelWidth)) {
+            padded += string(labelWidth - currentWidth, ' ');
+        }
+        padded += string(valueGap, ' ');
+        return color(c) + padded + color(Color::Reset) + value;
+    };
+
+    std::vector<string> infoLines = {
+        formatLine(Color::Green, " distro:", getDistro()),
+        formatLine(Color::Magenta, " kernel:", getKernel()),
+        formatLine(Color::Blue, " uptime:", getUptime()),
+        formatLine(Color::Magenta, " shell:", getShell()),
+        formatLine(Color::Yellow, "󰍛 CPU:", getCPU()),
+        formatLine(Color::Yellow, "󰾲 GPU:", getGPU()),
+        formatLine(Color::Red, " RAM:", getRAM()),
+        formatLine(Color::Blue, " OS Date:", getOsDate())
+    };
+
+    std::vector<string> logoLines = distroArt();
+    size_t logoWidth = 0;
+    for (const auto& line : logoLines) {
+        if (line.size() > logoWidth) logoWidth = line.size();
+    }
+
+    const string gap = "   ";
+    cout << string(logoWidth, ' ') << gap
+         << "--- " << color(Color::Green) << getUser() << color(Color::Reset)
+         << "@" << color(Color::Red) << getHost() << color(Color::Reset) << " ---\n";
+    cout << "\n";
+
+    size_t totalLines = infoLines.size();
+    if (logoLines.size() > totalLines) totalLines = logoLines.size();
+
+    for (size_t i = 0; i < totalLines; ++i) {
+        if (i < logoLines.size()) {
+            cout << logoLines[i];
+            if (logoLines[i].size() < logoWidth) {
+                cout << string(logoWidth - logoLines[i].size(), ' ');
+            }
+        } else {
+            cout << string(logoWidth, ' ');
+        }
+
+        cout << gap;
+
+        if (i < infoLines.size()) {
+            cout << infoLines[i];
+        }
+
+        cout << "\n";
+    }
 
     return 0;
 }
@@ -113,7 +212,7 @@ string getDistro() {
         if(delimiter != string::npos) {
             string key = line.substr(0, delimiter);
 
-            if (key == "NAME"){ 
+            if (key == "PRETTY_NAME"){
                 distroName = line.substr(delimiter + 1);
                 distroName = distroName.substr(1, distroName.length() - 2);
             }
@@ -126,6 +225,247 @@ string getDistro() {
     else return "";
 }
 
+string color(Color c) {
+    switch (c) {
+        case Color::Red:
+        case Color::RedLight:
+        case Color::RedDeep:
+            return "\033[1;31m";
+        case Color::Green:
+        case Color::GreenLight:
+        case Color::GreenDeep:
+            return "\033[1;32m";
+        case Color::Blue:
+        case Color::BlueLight:
+        case Color::BlueDeep:
+            return "\033[1;34m";
+        case Color::Yellow:
+        case Color::YellowLight:
+        case Color::Orange:
+        case Color::OrangeLight:
+        case Color::OrangeDeep:
+            return "\033[1;33m";
+        case Color::Magenta:
+        case Color::Purple:
+        case Color::PurpleLight:
+        case Color::PurpleDeep:
+            return "\033[1;35m";
+        case Color::Cyan:
+            return "\033[1;36m";
+        case Color::Gray:
+        case Color::Dark:
+            return "\033[1;37m";
+        case Color::Reset:
+            return "\033[0m";
+    }
+
+    return "\033[0m";
+}
+
+std::vector<string> distroArt() {
+    std::ifstream readOsRelease("/etc/os-release");
+
+    if(!readOsRelease.is_open()) {
+        std::cerr << "Error: Couldn't read /etc/os-release\n";
+    }
+
+    string distroID;
+    string line;
+    while (std::getline(readOsRelease, line)) {
+        if(line.empty() || line[0] == '#') continue;
+
+        std::size_t delimiter = line.find("=");
+        if(delimiter != string::npos) {
+            string key = line.substr(0, delimiter);
+
+            if (key == "ID"){
+                distroID = line.substr(delimiter + 1);
+                if (distroID[0] == '"' && distroID[distroID.length() - 1] == '"') distroID = distroID.substr(1, distroID.length() - 2);
+            }
+        }
+    }
+
+    readOsRelease.close();
+
+    const std::vector<DistroLogo> logos = {
+        {
+            "arch",
+            Color::Blue,
+            {
+                "      /\\      ",
+                "     /  \\     ",
+                "    /    \\    ",
+                "   /      \\   ",
+                "  /   ,,   \\  ",
+                " /   |  |   \\ ",
+                "/_-''    ''-_\\",
+                "               "
+            }
+        },
+        {
+            "cachyos",
+            Color::Green,
+            {
+                "   /''''''''''''/   ",
+                "  /''''''''''''/    ",
+                " /''''''/           ",
+                "/''''''/            ",
+                "\\......\\          ",
+                " \\......\\         ",
+                "  \\.............../",
+                "   \\............./ "
+            }
+        },
+        {
+            "debian",
+            Color::Red,
+            {
+                "  _____  ",
+                " /  __ \\",
+                "|  /    |",
+                "|  \\___-",
+                "-_       ",
+                "  --_    ",
+                "         ",
+                "         "
+            }
+        },
+        {
+            "ubuntu",
+            Color::Orange,
+            {
+               "       _  ",
+               "   ,--(_) ",
+               " _/ ;-._\\ ",
+               "(_)(   ) )",
+               "  \\ ;-'_/ ",
+               "   `--(_) "
+            }
+        },
+        {
+            "fedora",
+            Color::Blue,
+            {
+                "       _____  ",
+                "     /   __)\\ ",
+                "     |  /  \\ \\",
+                "  ___|  |__/ /",
+                " / (_    _)_/ ",
+                "/ /  |  |     ",
+                "\\ \\__/  |     ",
+                " \\(_____/     ",
+            }
+        },
+        {
+            "manjaro",
+            Color::Green,
+            {
+                "||||||||| ||||",
+                "||||||||| ||||",
+                "||||      ||||",
+                "|||| |||| ||||",
+                "|||| |||| ||||",
+                "|||| |||| ||||",
+                "|||| |||| ||||",
+                "              "
+            }
+        },
+        {
+            "opensuse",
+            Color::Green,
+            {
+                "  _______  ",
+                "__|   __ \\ ",
+                "     / .\\ \\",
+                "     \\__/ |",
+                "   _______|",
+                "   \\_______",
+                "__________/",
+                "           "
+            }
+        },
+        {
+            "pop",
+            Color::Cyan,
+            {
+                "______           ",
+                "\\   _ \\        __",
+                " \\ \\ \\ \\      / /",
+                "  \\ \\_\\ \\    / / ",
+                "   \\  ___\\  /_/  ",
+                "    \\ \\    _     ",
+                "   __\\_\\__(_)_   ",
+                "  (___________)` "
+            }
+        },
+        {
+            "linuxmint",
+            Color::Green,
+            {
+                " __________  ",
+                "|_          \\",
+                "  | | _____ |",
+                "  | | | | | |",
+                "  | | | | | |",
+                "  | \\_____/ |",
+                "  \\_________/",
+            }
+        },
+        {
+            "endeavouros",
+            Color::Purple,
+            {
+                "          /o.       ",
+                "        /sssso-     ",
+                "      /ossssssso:   ",
+                "    /ssssssssssso+  ",
+                "  /ssssssssssssssso+",
+                "//osssssssssssssso+-",
+                " `+++++++++++++++-` "
+            }
+        },
+        {
+            "void",
+            Color::Green,
+            {
+                "    ____   ",
+                "  'pfPfp.% ",
+                "//  _._  \\\\",
+                "UU |===| UU",
+                "\\\\  ^~^  //",
+                " `0PpppP'  ",
+                "   `````   "
+            }
+        },
+        {
+            "alpine",
+            Color::Blue,
+            {
+                "   /\\ /\\    ",
+                "  // \\  \\   ",
+                " //   \\  \\  ",
+                "///    \\  \\ ",
+                "//      \\  \\",
+                "         \\  "
+            }
+        },
+    };
+
+    std::vector<string> out;
+    for (const auto& logo : logos) {
+        if (logo.id == distroID) {
+            const string prefix = color(logo.color);
+            const string suffix = color(Color::Reset);
+            for (const auto& line : logo.art) {
+                out.push_back(prefix + line + suffix);
+            }
+            return out;
+        }
+    }
+
+    return out;
+}
+
 string getKernel() {
     struct utsname kernelInfo;