add README.md and fix minor issue

Reviewed-on: #1

LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2025 GarandPLG
+
+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.

README.md

@@ -1 +1,168 @@
 # GarandOS TUI
+
+## Overview
+
+GarandOS TUI is a terminal-based user interface tool designed to simplify the management of enabled modules in GarandOS NixOS configurations. It allows users to easily view and toggle boolean configuration options in both system and home module files through an intuitive interface.
+
+![GarandOS TUI Screenshot](./garandos-tui-presentation.png)
+
+## Features
+
+- Dual-pane interface for managing both system and home modules
+- Categorized view of configuration options
+- Simple keyboard navigation
+- Real-time toggle of boolean values in Nix configuration files
+- Automatic parsing and writing of Nix configuration syntax
+- Available via flake.nix
+
+## Installation
+
+### Using Nix
+
+#### As a Standalone Package
+
+```bash
+# Clone the repository
+git clone https://gitea.garandplg.com/GarandPLG/garandos-tui.git
+cd garandos-tui
+
+# Build using Nix
+nix build
+
+# Run the application
+nix run
+```
+
+### Building from Source
+
+```bash
+# Clone the repository
+git clone https://gitea.garandplg.com/GarandPLG/garandos-tui.git
+cd garandos-tui
+
+# Build with Cargo
+cargo build --release
+
+# Run the application
+cargo run -- --sf /path/to/system-modules.nix --hf /path/to/home-modules.nix
+```
+
+## Usage
+
+```bash
+garandos-tui --help
+
+garandos-tui --sf /path/to/system-modules.nix --hf /path/to/home-modules.nix
+```
+
+Where:
+- `--sf` specifies the path to your system modules file
+- `--hf` specifies the path to your home modules file
+
+In GarandOS, these files are located in:
+```
+~/garandos/hosts/<hostname>/system-modules.nix
+~/garandos/hosts/<hostname>/home-modules.nix
+```
+
+## Controls
+
+| Key                | Action                         |
+|--------------------|--------------------------------|
+| `↑` / `↓`          | Navigate options               |
+| `Enter` / `Space`  | Toggle selected option         |
+| `1` / `←`          | Switch to System modules       |
+| `2` / `→`          | Switch to Home modules         |
+| `q`                | Quit application               |
+
+## Interface
+
+The GarandOS TUI interface is divided into three main sections:
+
+1. **Header** - Shows the application title
+2. **Content Area** - Displays the configuration options, organized by categories
+3. **Footer** - Shows key bindings and the last action performed
+
+Options are displayed with checkboxes:
+- `☐` - Option is disabled (false)
+- `☑` - Option is enabled (true)
+
+## Configuration Format
+
+GarandOS TUI works with Nix configuration files that use a specific structure of boolean options. Options are organized by category using comments, for example:
+
+```nix
+_: {
+  /*
+  Container & Packaging
+  */
+  docker.enable = true; # Docker: container runtime and management
+  flatpak = {
+    enable = true; # Flatpak: universal packaging system for Linux
+    packages = {
+      sober.enable = false; # Roblox client
+      warehouse.enable = true; # Flatpak manager
+      flatseal.enable = true; # Flatpak permissions manager
+    };
+  };
+
+  /*
+  Gaming
+  */
+  gamemode.enable = true; # GameMode: optimizes system performance for gaming
+  gamescope.enable = false; # Gamescope: micro‑compositor for games
+  steam.enable = true; # Steam: platform for buying and playing games
+}
+```
+
+## NixOS Module Configuration
+
+When using GarandOS TUI as a NixOS module, the following options are available:
+
+| Option                | Description                                  | Default               |
+|-----------------------|----------------------------------------------|----------------------|
+| `enable`              | Enable the GarandOS TUI module               | `false`              |
+| `package`             | The GarandOS TUI package to use              | Default package      |
+| `systemModulesFilePath` | Path to system modules file                | `""`                 |
+| `homeModulesFilePath` | Path to home modules file                    | `""`                 |
+
+## Development
+
+### Development Environment
+
+A development shell is provided via Nix:
+
+```bash
+# Enter development shell
+nix develop
+
+# Available commands in the shell:
+# - nix build            - Build production version
+# - nix run              - Run production version
+# - nix build .#develop  - Build development version
+# - nix run .#develop    - Run development version
+```
+
+### Project Structure
+
+- `src/`
+  - `main.rs` - Application entry point
+  - `app.rs` - TUI application logic
+  - `cli.rs` - Command-line interface
+  - `nix.rs` - Nix file parsing and manipulation
+  - `lib.rs` - Module exports
+
+## License
+
+GarandOS TUI is licensed under the MIT License. See the [LICENSE](./LICENCE) file for details.
+
+## Authors
+
+- GarandPLG - [Gitea](https://gitea.garandplg.com/GarandPLG)
+
+## Acknowledgments
+
+- [ratatui](https://github.com/ratatui-org/ratatui) - Terminal UI library
+- [rnix](https://github.com/nix-community/rnix-parser) - Nix parser library
+- [clap](https://github.com/clap-rs/clap) - Command-line argument parser
+- [crossterm](https://github.com/crossterm-rs/crossterm) - Terminal manipulation library

default.nix

@@ -5,8 +5,20 @@
 }:
 rustPlatform.buildRustPackage {
   name = "garandos-tui";
+  pname = "garandos-tui";
+  version = "0.1.0";
+
   src = ./.;
   # buildInputs = [ ];
   nativeBuildInputs = [pkg-config];
-  cargoHash = lib.fakeHash;
+  cargoHash = "sha256-cFAkKwgLzj6Hr2pq7W/1Ps1G3yKzgEam/qV6p31gadA=";
+
+  meta = {
+    description = "TUI for managing GarandsOS' hosts enabled modules";
+    homepage = "https://gitea.garandplg.com/GarandPLG/garandos-tui";
+    license = lib.licenses.mit;
+    maintainers = [
+      "Garand_PLG"
+    ];
+  };
 }

flake.nix

@@ -1,5 +1,5 @@
 {
-  description = "TUI for managing GarandsOS' hosts configuration";
+  description = "TUI for managing GarandsOS' hosts enabled modules";
 
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
@@ -32,10 +32,6 @@
       cargo = rustToolchain;
       rustc = rustToolchain;
     };
-
-    cargoToml = builtins.fromTOML (builtins.readFile ./Cargo.toml);
-    packageVersion = cargoToml.package.version;
-    # ...
   in {
     packages.${system} = {
       default =
@@ -44,11 +40,56 @@
       develop = naerskLib.buildPackage {
         name = "garandos-tui";
         src = ./.;
-        # buildInputs = with pkgs; [];
         nativeBuildInputs = with pkgs; [pkg-config];
       };
     };
 
+    nixosModules.garandos-tui = {
+      config,
+      lib,
+      ...
+    }: let
+      inherit (lib) mkOption mkIf types;
+      cfg = config.programs.garandos-tui;
+    in {
+      options.programs.garandos-tui = {
+        enable = mkOption {
+          type = types.bool;
+          default = false;
+          description = "Enable the Garandos TUI module";
+        };
+        package = mkOption {
+          type = types.package;
+          default = self.packages.${system}.default;
+          defaultText = "self.packages.${system}.default";
+          description = "The Garandos TUI package";
+        };
+        systemModulesFilePath = mkOption {
+          type = types.path;
+          default = "";
+          example = "/home/\${username}/garandos/hosts/\${hostname}/system-modules.nix";
+          description = "The path to the Host's system modules file";
+        };
+        homeModulesFilePath = mkOption {
+          type = types.path;
+          default = "";
+          example = "/home/\${username}/garandos/hosts/\${hostname}/home-modules.nix";
+          description = "The path to the Host's home modules file";
+        };
+      };
+      config = mkIf (cfg.enable && cfg.systemModulesFilePath != "" && cfg.homeModulesFilePath != "") {
+        environment.systemPackages = [
+          (pkgs.writeScriptBin "garandos-tui" ''
+            #!${pkgs.runtimeShell}
+            exec ${cfg.package}/bin/garandos_tui \
+              --sf '${cfg.systemModulesFilePath}' \
+              --hf '${cfg.homeModulesFilePath}' \
+              "$@"
+          '')
+        ];
+      };
+    };
+
     devShells.${system}.default = pkgs.mkShell {
       env.RUST_SRC_PATH = "${pkgs.rust.packages.stable.rustPlatform.rustLibSrc}";
       buildInputs = [
@@ -57,8 +98,6 @@
       nativeBuildInputs = with pkgs; [pkg-config];
 
       shellHook = ''
-        echo "garandos-tui    v${packageVersion}"
-        echo ""
         echo "Commands:"
         echo "    nix build            - Build production version"
         echo "    nix run              - Run production version"

src/app.rs

@@ -1,20 +1,29 @@
-use crate::nix::{ConfigOption, ConfigSource};
+use crate::nix::{
+    ConfigOption, ConfigSource, collect_nix_options, get_nix_value_by_path, toggle_bool_at_path,
+};
 use crossterm::event::{self, KeyCode, KeyEvent, KeyEventKind};
 use ratatui::{
     DefaultTerminal, Frame,
     buffer::Buffer,
     layout::{Constraint, Layout, Rect},
-    style::Stylize,
+    style::{Color, Stylize},
     text::{Line, Span},
-    widgets::Widget,
+    widgets::{Block, Borders, Paragraph, Widget},
 };
+use rnix::{Parse, Root, SyntaxNode};
 use std::{
+    fs,
     io::Result,
+    path::PathBuf,
     sync::mpsc::{self, Receiver},
 };
 
 pub struct App {
     pub exit: bool,
+    pub system_path: PathBuf,
+    pub home_path: PathBuf,
+    pub system_ast: Parse<Root>,
+    pub home_ast: Parse<Root>,
     pub system_modules: Vec<ConfigOption>,
     pub home_modules: Vec<ConfigOption>,
     pub current_file: ConfigSource,
@@ -24,22 +33,20 @@ pub struct App {
 
 pub enum Event {
     Input(KeyEvent),
-    EditFile,
 }
 
 impl App {
     pub fn run(&mut self, terminal: &mut DefaultTerminal, rx: Receiver<Event>) -> Result<()> {
         while !self.exit {
+            terminal.draw(|frame: &mut Frame<'_>| self.draw(frame))?;
+
             let event: Event = match rx.recv() {
                 Ok(ev) => ev,
                 Err(_) => break,
             };
             match event {
                 Event::Input(key_event) => self.handle_key_event(key_event)?,
-                // Event::EditFile => self.handle_file_edit_events()?,
-                _ => {}
             }
-            terminal.draw(|frame: &mut Frame<'_>| self.draw(frame))?;
         }
 
         Ok(())
@@ -54,36 +61,122 @@ impl App {
         if key_event.kind == KeyEventKind::Press && key_event.code == KeyCode::Char('q') {
             self.exit = true;
         }
+        // 1/← - zmień plik na ConfigSource::System (pomiń wykonywaniej, jeżeli już jest wybrany)
+        else if key_event.kind == KeyEventKind::Press
+            && (key_event.code == KeyCode::Char('1') || key_event.code == KeyCode::Left)
+        {
+            self.current_file = ConfigSource::System;
+            self.selected_index = 0_usize;
+        }
+        // 2/→ - zmień plik na ConfigSource::Home (pomiń wykonywaniej, jeżeli już jest wybrany)
+        else if key_event.kind == KeyEventKind::Press
+            && (key_event.code == KeyCode::Char('2') || key_event.code == KeyCode::Right)
+        {
+            self.current_file = ConfigSource::Home;
+            self.selected_index = 0_usize;
+        }
         // ↑ - scroll w górę
         else if key_event.kind == KeyEventKind::Press && key_event.code == KeyCode::Up {
             self.selected_index = self.selected_index.saturating_sub(1);
         }
         // ↓ - scroll w dół
         else if key_event.kind == KeyEventKind::Press && key_event.code == KeyCode::Down {
-            self.selected_index = self.selected_index.saturating_add(1);
+            let max_index = match self.current_file {
+                ConfigSource::System => self.system_modules.len() - 1,
+                ConfigSource::Home => self.home_modules.len() - 1,
+            };
+            self.selected_index = self.selected_index.saturating_add(1).min(max_index);
         }
-        // ENTER - zmień wartość boolen danej opcji
+        // ENTER/SPACE - zmień wartość boolen danej opcji
-        else if key_event.kind == KeyEventKind::Press && key_event.code == KeyCode::Enter {
+        else if key_event.kind == KeyEventKind::Press
-        }
+            && (key_event.code == KeyCode::Enter || key_event.code == KeyCode::Char(' '))
-        // 1 - zmień plik na ConfigSource::System (pomiń wykonywaniej, jeżeli już jest wybrany)
+        {
-        else if key_event.kind == KeyEventKind::Press && key_event.code == KeyCode::Char('1') {
+            let (modules, new_node, new_ast, new_modules, new_module_value) =
-            if self.current_file != ConfigSource::System {
+                self.get_selected_option_context();
-                self.current_file = ConfigSource::System;
+
+            self.last_action_status = if let Some(module) = modules.get(self.selected_index) {
+                match self.current_file {
+                    ConfigSource::System => {
+                        self.system_modules = new_modules;
+                        self.system_ast = new_ast;
+                        fs::write(&self.system_path, new_node.to_string())
+                            .expect("Nie można zapisać pliku modułów systemowych");
+                    }
+                    ConfigSource::Home => {
+                        self.home_modules = new_modules;
+                        self.home_ast = new_ast;
+                        fs::write(&self.home_path, new_node.to_string())
+                            .expect("Nie można zapisać pliku modułów domowych");
+                    }
+                };
+                format!(
+                    "{} = {} -> {}",
+                    module.path.clone(),
+                    module.value.clone(),
+                    new_module_value
+                )
             } else {
-                self.current_file = ConfigSource::Home;
+                "Nothing changed".to_string()
-            }
+            };
-        }
-        // 2 - zmień plik na ConfigSource::Home (pomiń wykonywaniej, jeżeli już jest wybrany)
-        else if key_event.kind == KeyEventKind::Press && key_event.code == KeyCode::Char('2') {
-            if self.current_file != ConfigSource::Home {
-                self.current_file = ConfigSource::Home;
-            } else {
-                self.current_file = ConfigSource::System;
-            }
         }
 
         Ok(())
     }
+
+    fn get_selected_option_context(
+        &self,
+    ) -> (
+        Vec<ConfigOption>,
+        SyntaxNode,
+        Parse<Root>,
+        Vec<ConfigOption>,
+        bool,
+    ) {
+        let modules: &Vec<ConfigOption> = match self.current_file {
+            ConfigSource::System => &self.system_modules,
+            ConfigSource::Home => &self.home_modules,
+        };
+        let node: &SyntaxNode = match self.current_file {
+            ConfigSource::System => &self.system_ast.syntax(),
+            ConfigSource::Home => &self.home_ast.syntax(),
+        };
+        let fallback_module_value: bool = modules
+            .get(self.selected_index)
+            .map(|m| m.value.clone())
+            .unwrap_or(false);
+
+        let (new_node, new_ast, new_modules, new_module_value) = match modules
+            .get(self.selected_index)
+        {
+            Some(module) => {
+                let new_node: SyntaxNode = toggle_bool_at_path(node, module.path.as_str());
+
+                let new_ast: Parse<Root> = Root::parse(&new_node.to_string().as_str());
+
+                let new_modules: Vec<ConfigOption> =
+                    collect_nix_options(&new_node, "", "".to_string(), self.current_file.clone());
+
+                let new_module_value: bool = get_nix_value_by_path(&new_node, module.path.as_str())
+                    .unwrap_or_else(|| module.value.clone());
+
+                (new_node, new_ast, new_modules, new_module_value)
+            }
+            None => (
+                node.clone(),
+                Root::parse(&node.to_string().as_str()),
+                Vec::new(),
+                fallback_module_value,
+            ),
+        };
+
+        (
+            modules.to_vec(),
+            new_node,
+            new_ast,
+            new_modules,
+            new_module_value,
+        )
+    }
 }
 
 impl Widget for &App {
@@ -92,32 +185,96 @@ impl Widget for &App {
         Self: Sized,
     {
         let vertical_layout: Layout = Layout::vertical([
-            Constraint::Percentage(10),
+            Constraint::Percentage(4),
-            Constraint::Percentage(80),
+            Constraint::Percentage(91),
-            Constraint::Percentage(10),
+            Constraint::Percentage(5),
         ]);
 
         let [title_area, content_area, footer_area] = vertical_layout.areas(area);
 
-        let (system_file, home_file) = match self.current_file {
+        {
-            ConfigSource::System => ("(System)".blue().bold(), "Home".reset()),
+            let title: Line<'_> =
-            ConfigSource::Home => ("System".reset(), "(Home)".blue().bold()),
+                Line::from("GarandOS TUI".bold().italic().yellow()).left_aligned();
-        };
-        let navbar: Line<'_> = Line::from(vec![
-            Span::from("GarandOS TUI".bold().italic().yellow()),
-            Span::from(" * ".reset()),
-            system_file,
-            Span::from(" [1]".reset()),
-            Span::from(" * ".reset()),
-            home_file,
-            Span::from(" [2]".reset()),
-            Span::from(" *".reset()),
-            Span::from(" Quit".reset()),
-            Span::from(" [q]".reset()),
-        ])
-        .left_aligned();
 
-        navbar.render(title_area, buf);
+            title.render(title_area, buf);
+        }
+
+        {
+            let modules: &Vec<ConfigOption> = match self.current_file {
+                ConfigSource::System => &self.system_modules,
+                ConfigSource::Home => &self.home_modules,
+            };
+
+            let mut lines: Vec<Line> = Vec::new();
+            let mut last_category: String = String::new();
+
+            for (idx, module) in modules.iter().enumerate() {
+                if module.category != last_category {
+                    lines.push("".into());
+                    let cat_line = Line::from(vec![
+                        Span::raw(format!("/* {} */", module.category))
+                            .dark_gray()
+                            .italic(),
+                    ]);
+                    lines.push(cat_line);
+                    last_category = module.category.clone();
+                }
+
+                let checkbox: &'static str = if module.value { "☑" } else { "☐" };
+
+                let mut line: Line<'_> =
+                    Line::from(vec![Span::raw(format!("{} {}", checkbox, module.path))]);
+
+                if idx == self.selected_index {
+                    line = line.style(Color::Yellow)
+                }
+
+                lines.push(line);
+            }
+
+            let block_title: &'static str = match self.current_file {
+                ConfigSource::System => "[ System Configuration ]",
+                ConfigSource::Home => "[ Home Configuration ]",
+            };
+
+            let content: Paragraph<'_> = Paragraph::new(lines)
+                .left_aligned()
+                .block(
+                    Block::default()
+                        .borders(Borders::ALL)
+                        .title(block_title.blue().bold()),
+                )
+                .scroll((self.selected_index as u16, 0));
+            content.render(content_area, buf);
+        }
+
+        {
+            let footer_line1: Line<'_> = Line::from(vec![
+                Span::from("Use "),
+                Span::from("↑/↓".italic().green()),
+                Span::from(" to navigate, "),
+                Span::from("Enter/Space".bold().yellow()),
+                Span::from(" to toggle, "),
+                Span::from("1/2 or ←/→".bold().blue()),
+                Span::from(" to switch file, "),
+                Span::from("q".bold().red()),
+                Span::from(" to quit."),
+            ]);
+            let last_action: Span<'_> = if self.last_action_status.is_empty() {
+                Span::from("Nothing changed")
+            } else {
+                self.last_action_status.clone().into()
+            };
+            let footer_line2: Line<'_> = Line::from(vec![
+                Span::from("Last action: "),
+                last_action.italic().green(),
+                Span::from("."),
+            ]);
+            let footer: Paragraph<'_> =
+                Paragraph::new(vec![footer_line1, footer_line2]).left_aligned();
+
+            footer.render(footer_area, buf);
+        }
     }
 }
 

src/cli.rs

@@ -1,7 +1,6 @@
-use crate::nix::{ConfigOption, ConfigSource, collect_nix_options};
+use crate::nix::{NixModules, build_nix_modules};
 use clap::Parser;
-use rnix::{Parse, Root};
+use std::path::PathBuf;
-use std::{fs, path::PathBuf};
 
 #[derive(Parser, Debug)]
 #[command(
@@ -24,41 +23,7 @@ pub struct Cli {
     pub hf: PathBuf,
 }
 
-pub struct NixModules {
-    pub system_modules: Vec<ConfigOption>,
-    pub home_modules: Vec<ConfigOption>,
-}
-
 pub fn get_modules() -> NixModules {
     let args: Cli = Cli::parse();
-
+    build_nix_modules(args.sf, args.hf)
-    let system_file: String = fs::read_to_string(&args.sf).expect("Failed to read system file");
-    let home_file: String = fs::read_to_string(&args.hf).expect("Failed to read home file");
-
-    let system_ast: Parse<Root> = get_ast(&system_file);
-    let home_ast: Parse<Root> = get_ast(&home_file);
-
-    let system_modules: Vec<ConfigOption> =
-        collect_nix_options(&system_ast.syntax(), "", ConfigSource::System);
-    let home_modules: Vec<ConfigOption> =
-        collect_nix_options(&home_ast.syntax(), "", ConfigSource::Home);
-
-    NixModules {
-        system_modules,
-        home_modules,
-    }
-}
-
-fn get_ast(file: &str) -> Parse<Root> {
-    let ast: Parse<Root> = Root::parse(&file);
-
-    if !ast.errors().is_empty() {
-        eprintln!("Błędy parsowania:");
-        for error in ast.errors() {
-            eprintln!("  - {}", error);
-        }
-        panic!("Błąd z parsowaniem pliku .nix")
-    }
-
-    ast
 }

src/main.rs

@@ -1,7 +1,7 @@
 use garandos_tui::{
     app::{App, Event, handle_input_events},
-    cli::{NixModules, get_modules},
+    cli::get_modules,
-    nix::ConfigSource,
+    nix::{ConfigSource, NixModules},
 };
 use ratatui::{Terminal, prelude::CrosstermBackend};
 use std::{
@@ -15,6 +15,10 @@ fn main() -> Result<()> {
     let mut terminal: Terminal<CrosstermBackend<Stdout>> = ratatui::init();
     let mut app: App = App {
         exit: false,
+        system_path: nix_modules.system_path,
+        home_path: nix_modules.home_path,
+        system_ast: nix_modules.system_ast,
+        home_ast: nix_modules.home_ast,
         system_modules: nix_modules.system_modules,
         home_modules: nix_modules.home_modules,
         current_file: ConfigSource::System,
@@ -29,11 +33,6 @@ fn main() -> Result<()> {
         handle_input_events(tx_to_input_events);
     });
 
-    // let tx_to_file_edit_events: Sender<Event> = event_tx.clone();
-    // thread::spawn(move || {
-    //     // handle_file_edit_events(tx_to_file_edit_events);
-    // });
-
     let app_result: Result<()> = app.run(&mut terminal, event_rx);
     ratatui::restore();
     app_result

src/nix.rs

@@ -1,6 +1,16 @@
-use rnix::{NodeOrToken, Root, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize};
+use rnix::{NodeOrToken, Parse, Root, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize};
-use std::collections::HashMap;
+use std::{collections::HashMap, fs, path::PathBuf};
 
+pub struct NixModules {
+    pub system_path: PathBuf,
+    pub system_ast: Parse<Root>,
+    pub system_modules: Vec<ConfigOption>,
+    pub home_path: PathBuf,
+    pub home_ast: Parse<Root>,
+    pub home_modules: Vec<ConfigOption>,
+}
+
+#[derive(Clone)]
 pub struct ConfigOption {
     pub category: String,
     pub path: String,
@@ -8,51 +18,53 @@ pub struct ConfigOption {
     pub source: ConfigSource,
 }
 
-#[derive(PartialEq)]
+#[derive(PartialEq, Clone)]
 pub enum ConfigSource {
     System,
     Home,
 }
 
-impl Clone for ConfigSource {
+pub fn parse_nix(src: &str) -> Parse<Root> {
-    fn clone(&self) -> Self {
+    let ast: Parse<Root> = Root::parse(src);
-        match self {
+    if !ast.errors().is_empty() {
-            ConfigSource::System => ConfigSource::System,
+        eprintln!("Błędy parsowania:");
-            ConfigSource::Home => ConfigSource::Home,
+        for err in ast.errors() {
+            eprintln!("  - {}", err);
         }
+        panic!("Błąd parsowania pliku .nix");
+    }
+    ast
+}
+
+pub fn build_nix_modules(system_path: PathBuf, home_path: PathBuf) -> NixModules {
+    let system_src: String = fs::read_to_string(&system_path).expect("Failed to read system file");
+    let home_src: String = fs::read_to_string(&home_path).expect("Failed to read home file");
+
+    let system_ast: Parse<Root> = parse_nix(&system_src);
+    let home_ast: Parse<Root> = parse_nix(&home_src);
+
+    let system_modules: Vec<ConfigOption> = collect_nix_options(
+        &system_ast.syntax(),
+        "",
+        "".to_string(),
+        ConfigSource::System,
+    );
+    let home_modules: Vec<ConfigOption> =
+        collect_nix_options(&home_ast.syntax(), "", "".to_string(), ConfigSource::Home);
+
+    NixModules {
+        system_path,
+        system_ast,
+        system_modules,
+        home_path,
+        home_ast,
+        home_modules,
     }
 }
 
-/// Pobiera wartość logiczną opcji Nix wskazanej pełną ścieżką.
-///
-/// # Argumenty
-///
-/// * `node` – korzeń drzewa składniowego Nix (`SyntaxNode`), uzyskany np.
-///   z `Root::parse(src).syntax()`.
-/// * `query_path` – pełna ścieżka do opcji, np. `services.ssh.enable`.
-///
-/// # Zwraca
-///
-/// `Some(true)` lub `Some(false)` jeśli opcja istnieje, w przeciwnym razie `None`.
-///
-/// # Przykład
-///
-/// ```
-/// use rnix::{Root, SyntaxNode};
-/// let src = r#"services.ssh.enable = true;"#;
-/// let parse = Root::parse(src);
-/// let root: SyntaxNode = parse.node();
-///
-/// // zwraca Some(true)
-/// let val = get_nix_value_by_path(&root, "services.ssh.enable");
-/// assert_eq!(val, Some(true));
-///
-/// // nieistniejąca opcja → None
-/// let missing = get_nix_value_by_path(&root, "services.httpd.enable");
-/// assert_eq!(missing, None);
-/// ```
 pub fn get_nix_value_by_path(node: &SyntaxNode, query_path: &str) -> Option<bool> {
-    let options: Vec<ConfigOption> = collect_nix_options(node, "", ConfigSource::System);
+    let options: Vec<ConfigOption> =
+        collect_nix_options(node, "", "".to_string(), ConfigSource::System);
 
     let map: HashMap<&str, bool> = options
         .iter()
@@ -62,36 +74,6 @@ pub fn get_nix_value_by_path(node: &SyntaxNode, query_path: &str) -> Option<bool
     map.get(query_path).copied()
 }
 
-/// Przełącza (toggle) wartość logiczną opcji w drzewie Nix określonej przez `query_path`.
-///
-/// Funkcja odczytuje tekst źródłowy z podanego węzła, znajduje zakres tekstowy
-/// odpowiadający wartości boolean i zamienia ją na przeciwną (`true` ↔ `false`).
-/// Zwraca nowy węzeł składniowy (`SyntaxNode`) reprezentujący zmodyfikowany
-/// kod Nix. Jeśli podana ścieżka nie zostanie znaleziona, zwracany jest węzeł
-/// niezmieniony.
-///
-/// # Argumenty
-///
-/// * `node` – korzeń drzewa składniowego Nix.
-/// * `query_path` – pełna ścieżka do opcji, której wartość ma zostać przełączona.
-///
-/// # Zwraca
-///
-/// `SyntaxNode` będący korzeniem drzewa składniowego po zastosowaniu zmiany.
-///
-/// # Przykład
-///
-/// ```
-/// use rnix::{Root, SyntaxNode};
-/// let src = r#"services.ssh.enable = true;"#;
-/// let parse = Root::parse(src);
-/// let root: SyntaxNode = parse.syntax();
-///
-/// // przełączamy wartość
-/// let new_root = toggle_bool_at_path(&root, "services.ssh.enable");
-/// let new_src = new_root.text();
-/// assert!(new_src.contains("services.ssh.enable = false"));
-/// ```
 pub fn toggle_bool_at_path(node: &SyntaxNode, query_path: &str) -> SyntaxNode {
     let src: String = node.text().to_string();
 
@@ -175,49 +157,13 @@ pub fn toggle_bool_at_path(node: &SyntaxNode, query_path: &str) -> SyntaxNode {
     }
 }
 
-/// Rekurencyjnie przegląda drzewo składniowe Nix i zbiera wszystkie opcje
-/// typu `bool`, uwzględniając aktualną ścieżkę oraz kategorię (pobrane z
-/// najbliższego blokowego komentarza).
-///
-/// # Argumenty
-///
-/// * `node` – bieżący węzeł drzewa składniowego.
-/// * `current_path` – dotychczasowa ścieżka do bieżącego węzła (pusty ciąg dla
-///   węzła korzenia).
-/// * `current_category` – nazwa kategorii pochodząca z najbliższego komentarza
-///   blokowego nad węzłem.
-///
-/// # Zwraca
-///
-/// `Vec<ConfigOption>` – wektor opcji z kategorią, pełną ścieżką i wartością bool.
-///
-/// # Przykład
-///
-/// ```
-/// use rnix::{Root, SyntaxNode};
-/// // przykładowe źródło Nix
-/// let src = r#"
-/// /* Services */
-/// services.ssh.enable = true;
-/// services.httpd.enable = false;
-/// "#;
-///
-/// // parsujemy źródło
-/// let ast = Root::parse(src);
-///
-/// // zbieramy wszystkie opcje bool
-/// let options = collect_nix_options(&ast.syntax(), "", ConfigSource::System);
-/// assert_eq!(options.len(), 2);
-/// assert!(options.iter().any(|option| option.path == "services.ssh.enable" && option.value));
-/// assert!(options.iter().any(|option| option.path == "services.httpd.enable" && !option.value));
-/// ```
 pub fn collect_nix_options(
     node: &SyntaxNode,
     current_path: &str,
+    mut current_category: String,
     current_source: ConfigSource,
 ) -> Vec<ConfigOption> {
     let mut result: Vec<ConfigOption> = Vec::new();
-    let mut category: String = String::new();
 
     let children: Vec<NodeOrToken<SyntaxNode, SyntaxToken>> = node.children_with_tokens().collect();
 
@@ -231,7 +177,7 @@ pub fn collect_nix_options(
                         .trim_end_matches("*/")
                         .trim()
                         .to_string();
-                    category = content;
+                    current_category = content;
                 }
             }
 
@@ -262,6 +208,7 @@ pub fn collect_nix_options(
                                 result.extend(collect_nix_options(
                                     &grand_node,
                                     &new_path,
+                                    current_category.clone(),
                                     current_source.clone(),
                                 ));
                             }
@@ -278,7 +225,7 @@ pub fn collect_nix_options(
                     };
                     let bool_value: bool = value_node.text() == "true";
                     result.push(ConfigOption {
-                        category: category.clone(),
+                        category: current_category.clone(),
                         path: full_path,
                         value: bool_value,
                         source: current_source.clone(),
@@ -290,6 +237,7 @@ pub fn collect_nix_options(
                 result.extend(collect_nix_options(
                     child_node,
                     current_path,
+                    current_category.clone(),
                     current_source.clone(),
                 ));
             }

src/placeholder.txt

@@ -1,224 +0,0 @@
-// main.rs
-use clap::Parser;
-use garandos_tui::{
-    cli::Cli,
-    // app::{App, Event, handle_input_events, run_background_thread},
-    nix::{
-        ConfigOption, ConfigSource, collect_nix_options, get_nix_value_by_path, toggle_bool_at_path,
-    },
-};
-// use ratatui::{Terminal, prelude::CrosstermBackend, style::Color};
-use rnix::{Parse, Root, SyntaxNode};
-use std::fs;
-// use std::{
-//     io,
-//     sync::mpsc::{self, Sender},
-//     thread,
-// };
-
-// fn main() -> io::Result<()> {
-//     let mut terminal: Terminal<CrosstermBackend<io::Stdout>> = ratatui::init();
-//     let mut app: App = App {
-//         exit: false,
-//         progress_bar_color: Color::Green,
-//         background_progress: 0_f64,
-//     };
-
-//     let (event_tx, event_rx) = mpsc::channel::<Event>();
-
-//     let tx_to_input_events: Sender<Event> = event_tx.clone();
-//     thread::spawn(move || {
-//         handle_input_events(tx_to_input_events);
-//     });
-
-//     let tx_to_background_events: Sender<Event> = event_tx.clone();
-//     thread::spawn(move || {
-//         run_background_thread(tx_to_background_events);
-//     });
-
-//     let app_result: Result<(), io::Error> = app.run(&mut terminal, event_rx);
-
-//     ratatui::restore();
-//     app_result
-// }
-
-// fn main() {
-//     let args: Cli = Cli::parse();
-
-//     let system_modules_content: String =
-//         fs::read_to_string(args.system_file).expect("Nie można odczytać pliku {args.system_file}");
-
-//     let home_modules_content: String =
-//         fs::read_to_string(args.home_file).expect("Nie można odczytać pliku {args.home_file}");
-
-//     let ast: Parse<Root> = Root::parse(&home_modules_content);
-
-//     if !ast.errors().is_empty() {
-//         eprintln!("Błędy parsowania:");
-//         for error in ast.errors() {
-//             eprintln!("  - {}", error);
-//         }
-//         eprintln!();
-//     }
-
-//     let node: SyntaxNode = ast.syntax();
-//     let options: Vec<ConfigOption> = collect_nix_options(&node, "", ConfigSource::System);
-
-//     const OPTION: &str = "flatpak.enable";
-
-//     println!("Options:");
-//     for option in options {
-//         // if option.path == OPTION {
-//         println!("{} = {};", option.path, option.value);
-//         // }
-//     }
-
-//     // if let Some(value) = get_nix_value_by_path(&node, OPTION) {
-//     //     println!("\n{OPTION}: {}", value);
-//     // }
-
-//     // let new_node: SyntaxNode = toggle_bool_at_path(&node, OPTION);
-//     // let new_options: Vec<ConfigOption> = collect_nix_options(&new_node, "", ConfigSource::System);
-
-//     // println!("\nNew Options:");
-//     // for option in new_options {
-//     //     if option.path == OPTION {
-//     //         println!("{} = {};", option.path, option.value);
-//     //     }
-//     // }
-
-//     // fs::write("src/test.nix", new_node.to_string()).expect("Nie można zapisać tego pliku");
-// }
-
-// app.rs
-
-// use core::option::Option;
-// use crossterm::{
-//     event,
-//     event::{KeyCode, KeyEvent, KeyEventKind},
-// };
-// use ratatui::{
-//     DefaultTerminal, Frame,
-//     prelude::{Buffer, Constraint, Layout, Rect, Stylize},
-//     style::{Color, Style},
-//     symbols::border,
-//     text::Line,
-//     widgets::{Block, Gauge, Widget},
-// };
-// use std::{io, sync::mpsc, thread, time::Duration};
-
-// pub fn handle_input_events(tx: mpsc::Sender<Event>) {
-//     loop {
-//         match event::read() {
-//             Ok(ev) => {
-//                 if let event::Event::Key(key_event) = ev {
-//                     if tx.send(Event::Input(key_event)).is_err() {
-//                         break;
-//                     }
-//                 }
-//             }
-//             Err(_) => {
-//                 continue;
-//             }
-//         }
-//     }
-// }
-
-// pub fn run_background_thread(tx: mpsc::Sender<Event>) {
-//     let mut progress: f64 = 0_f64;
-//     const INCREMENT: f64 = 0.01_f64;
-//     loop {
-//         thread::sleep(Duration::from_millis(100));
-//         progress += INCREMENT;
-//         progress = progress.min(1_f64);
-//         if tx.send(Event::Progress(progress)).is_err() {
-//             break;
-//         }
-//     }
-// }
-
-// impl App {
-//     pub fn run(
-//         &mut self,
-//         terminal: &mut DefaultTerminal,
-//         rx: mpsc::Receiver<Event>,
-//     ) -> io::Result<()> {
-//         while !self.exit {
-//             let event: Event = match rx.recv() {
-//                 Ok(ev) => ev,
-//                 Err(_) => break,
-//             };
-//             match event {
-//                 Event::Input(key_event) => self.handle_key_event(key_event)?,
-//                 Event::Progress(progress) => self.background_progress = progress,
-//             }
-//             terminal.draw(|frame: &mut Frame<'_>| self.draw(frame))?;
-//         }
-
-//         Ok(())
-//     }
-
-//     fn draw(&self, frame: &mut Frame<'_>) {
-//         frame.render_widget(self, frame.area());
-//     }
-
-//     fn handle_key_event(&mut self, key_event: KeyEvent) -> io::Result<()> {
-//         if key_event.kind == KeyEventKind::Press && key_event.code == KeyCode::Char('q') {
-//             self.exit = true;
-//         } else if key_event.kind == KeyEventKind::Press && key_event.code == KeyCode::Char('c') {
-//             if self.progress_bar_color == Color::Green {
-//                 self.progress_bar_color = Color::Red;
-//             } else {
-//                 self.progress_bar_color = Color::Green;
-//             }
-//         }
-//         Ok(())
-//     }
-// }
-
-// impl Widget for &App {
-//     fn render(self, area: Rect, buf: &mut Buffer)
-//     where
-//         Self: Sized,
-//     {
-//         let vertical_layout: Layout =
-//             Layout::vertical([Constraint::Percentage(20), Constraint::Percentage(80)]);
-//         let [title_area, gauge_area] = vertical_layout.areas(area);
-
-//         Line::from("Process overview")
-//             .bold()
-//             .render(title_area, buf);
-
-//         let instructions: Line<'_> = Line::from(vec![
-//             " Change color ".into(),
-//             "<C>".blue().bold(),
-//             " Quit ".into(),
-//             "<Q>".blue().bold(),
-//         ])
-//         .centered();
-
-//         let block: Block<'_> = Block::bordered()
-//             .title(Line::from(" Background processes "))
-//             .title_bottom(instructions)
-//             .border_set(border::THICK);
-
-//         let progress_bar: Gauge<'_> = Gauge::default()
-//             .gauge_style(Style::default().fg(self.progress_bar_color))
-//             .block(block)
-//             .label(format!(
-//                 "Process Bar: {:.2}%",
-//                 self.background_progress * 100_f64
-//             ))
-//             .ratio(self.background_progress);
-
-//         progress_bar.render(
-//             Rect {
-//                 x: gauge_area.left(),
-//                 y: gauge_area.top(),
-//                 width: gauge_area.width,
-//                 height: 3,
-//             },
-//             buf,
-//         );
-//     }
-// }

src/test.nix

@@ -1,76 +0,0 @@
-_: {
-  /*
-  Container & Packaging
-  */
-  docker.enable = true; # Docker: container runtime and management
-  flatpak = {
-    enable = true; # Flatpak: universal packaging system for Linux
-    packages = {
-      sober.enable = false; # Roblox client
-      warehouse.enable = true; # Flatpak manager
-      flatseal.enable = true; # Flatpak permissions manager
-    };
-  };
-
-  /*
-  Gaming
-  */
-  gamemode.enable = true; # GameMode: optimizes system performance for gaming
-  gamescope.enable = false; # Gamescope: micro‑compositor for games
-  steam.enable = true; # Steam: platform for buying and playing games
-
-  packages = {
-    /*
-    Container & Packaging
-    */
-    distrobox.enable = false; # Distrobox: containerized development environments
-    lazydocker.enable = false; # Lazydocker: simple TUI for Docker
-
-    /*
-    Gaming
-    */
-    prismlauncher.enable = false; # Prism Launcher: Minecraft modded launcher
-    spaceCadetPinball.enable = true; # SpaceCadet Pinball: classic pinball game
-    ttySolitaire.enable = true; # TTY Solitaire: terminal‑based solitaire game
-
-    /*
-    Development Tools
-    */
-    exercism.enable = true; # Exercism: coding practice platform
-    lazygit.enable = false; # Lazygit: simple TUI for Git
-    opencode.enable = true; # OpenCode: tools for coding and development
-    jan.enable = true; # Jan: AI chat UI
-
-    /*
-    Communication & Collaboration
-    */
-    mattermost.enable = true; # Mattermost: open‑source Slack alternative
-    slack.enable = true; # Slack: team communication and collaboration tool
-    tutanota.enable = true; # Tutanota: secure email client
-
-    /*
-    Productivity / Knowledge Management
-    */
-    bitwarden.enable = false; # Bitwarden: password manager (desktop)
-    iotas.enable = true; # Iotas: lightweight notes manager
-    logseq.enable = false; # Logseq: knowledge base and outliner
-
-    /*
-    Media & Graphics
-    */
-    affinity.enable = false; # Affinity: professional graphics suite
-    eyeOfGnome.enable = true; # Eye of GNOME: image viewer
-    freetube.enable = false; # FreeTube: privacy‑friendly YouTube client
-    gimp.enable = false; # GIMP: GNU Image Manipulation Program
-    kdenlive.enable = false; # Kdenlive: video editing software
-    plex.enable = true; # Plex: media player and server client
-
-    /*
-    Utilities / Misc
-    */
-    eddieAirVPN.enable = true; # Eddie AirVPN: VPN client
-    galculator.enable = true; # Galculator: simple calculator
-    gedit.enable = false; # Gedit: GNOME text editor
-    winboat.enable = false; # Winboat: Windows remote desktop via RDP
-  };
-}