stuff

lib/examples/default.nix

@@ -0,0 +1,8 @@
+{ inputs, ... }:
+{
+  # Import all examples
+  sops = import ./sops.nix;
+  homeSops = import ./home-sops.nix;
+  fileUtils = import ./file-utils.nix;
+  systemUtils = import ./system-utils.nix;
+}

lib/examples/file-utils.nix

@@ -0,0 +1,58 @@
+{ lib, ... }:
+let
+  inherit (lib.mjallen.file) 
+    readFile 
+    pathExists 
+    safeImport 
+    scanDir 
+    getFile 
+    importModulesRecursive
+    scanSystems
+    filterNixOSSystems
+    filterDarwinSystems
+    scanHomes;
+in
+{
+  # Example of reading a file
+  myFileContent = readFile ./example.txt;
+  
+  # Example of checking if a file exists
+  fileExists = pathExists ./example.txt;
+  
+  # Example of safely importing a file
+  myConfig = safeImport ./my-config.nix {};
+  
+  # Example of scanning a directory
+  directoryContents = scanDir ./modules;
+  
+  # Example of getting a file path relative to the flake root
+  flakeFile = getFile "flake.nix";
+  
+  # Example of importing modules recursively
+  modules = importModulesRecursive ./modules;
+  
+  # Example of scanning systems
+  allSystems = scanSystems ./systems;
+  
+  # Example of filtering systems
+  nixosSystems = filterNixOSSystems allSystems;
+  darwinSystems = filterDarwinSystems allSystems;
+  
+  # Example of scanning homes
+  allHomes = scanHomes ./homes;
+  
+  # Example of using these functions together
+  nixosConfigurations = lib.mapAttrs' (
+    name:
+    { system, hostname, ... }:
+    {
+      name = hostname;
+      value = lib.nixosSystem {
+        inherit system;
+        modules = [
+          { networking.hostName = hostname; }
+        ] ++ importModulesRecursive ./modules/nixos;
+      };
+    }
+  ) nixosSystems;
+}

lib/examples/home-sops.nix

@@ -0,0 +1,31 @@
+{ config, lib, pkgs, ... }:
+let
+  inherit (lib.mjallen.module) mkModule mkOpt mkBoolOpt;
+in
+mkModule {
+  name = "sops";
+  description = "SOPS secret management for home-manager";
+  options = {
+    defaultSopsFile = mkOpt lib.types.path null "Default sops file.";
+    
+    sshKeyPaths = mkOpt (lib.types.listOf lib.types.str) [] "SSH Key paths to use.";
+  };
+  config = {
+    home.packages = with pkgs; [
+      age
+      sops
+      ssh-to-age
+    ];
+
+    sops = {
+      inherit (config.mjallen.sops) defaultSopsFile;
+      defaultSopsFormat = "yaml";
+
+      age = {
+        generateKey = true;
+        keyFile = "${config.home.homeDirectory}/.config/sops/age/keys.txt";
+        sshKeyPaths = [ "${config.home.homeDirectory}/.ssh/id_ed25519" ] ++ config.mjallen.sops.sshKeyPaths;
+      };
+    };
+  };
+}

lib/examples/sops.nix

@@ -0,0 +1,36 @@
+{ config, lib, ... }:
+let
+  inherit (lib.mjallen.module) mkModule mkOpt mkBoolOpt;
+in
+mkModule {
+  name = "sops";
+  description = "SOPS secret management";
+  options = {
+    defaultSopsFile = mkOpt lib.types.path null "Default sops file.";
+    
+    generateAgeKey = mkBoolOpt true "Whether to automatically generate an age key if one doesn't exist.";
+    
+    ageKeyPath = mkOpt (lib.types.nullOr lib.types.str) null "Custom path to the age key file. If null, will use the default path.";
+    
+    sshKeyPaths = mkOpt (lib.types.listOf lib.types.str) [
+      "/etc/ssh/ssh_host_ed25519_key"
+    ] "SSH Key paths to use.";
+    
+    validateSopsFiles = mkBoolOpt false "Whether to validate that sops files exist.";
+  };
+  config = {
+    sops = {
+      inherit (config.mjallen.sops) defaultSopsFile validateSopsFiles;
+
+      age = {
+        inherit (config.mjallen.sops) generateAgeKey;
+        
+        keyFile = if config.mjallen.sops.ageKeyPath != null 
+                  then config.mjallen.sops.ageKeyPath
+                  else "${config.users.users.${config.mjallen.user.name}.home}/.config/sops/age/keys.txt";
+                  
+        sshKeyPaths = config.mjallen.sops.sshKeyPaths;
+      };
+    };
+  };
+}

lib/examples/system-utils.nix

@@ -0,0 +1,111 @@
+{ inputs, ... }:
+let
+  inherit (inputs.self.mjallen-lib.system.common) 
+    mkExtendedLib
+    mkNixpkgsConfig
+    mkHomeConfigs
+    mkHomeManagerConfig
+    mkSpecialArgs;
+in
+{
+  # Example of creating NixOS configurations
+  nixosConfigurations = 
+    let
+      # Get all systems
+      allSystems = inputs.self.mjallen-lib.file.scanSystems ../systems;
+      
+      # Filter for NixOS systems
+      nixosSystems = inputs.self.mjallen-lib.file.filterNixOSSystems allSystems;
+    in
+    inputs.nixpkgs.lib.mapAttrs' (
+      name:
+      { system, hostname, ... }:
+      let
+        # Create extended lib with mjallen-lib
+        extendedLib = mkExtendedLib inputs.self inputs.nixpkgs;
+        
+        # Find matching home configurations for this system
+        matchingHomes = mkHomeConfigs {
+          flake = inputs.self;
+          inherit system hostname;
+        };
+        
+        # Create home-manager configuration
+        homeManagerConfig = mkHomeManagerConfig {
+          inherit extendedLib inputs system matchingHomes;
+          isNixOS = true;
+        };
+      in
+      {
+        name = hostname;
+        value = inputs.nixpkgs.lib.nixosSystem {
+          inherit system;
+          
+          # Pass special arguments to modules
+          specialArgs = mkSpecialArgs {
+            inherit inputs hostname extendedLib;
+            username = "mjallen";
+          };
+          
+          modules = [
+            # Set lib to extended lib
+            { _module.args.lib = extendedLib; }
+            
+            # Configure nixpkgs
+            {
+              nixpkgs = {
+                inherit system;
+              } // mkNixpkgsConfig inputs.self;
+            }
+            
+            # Import home-manager module
+            inputs.home-manager.nixosModules.home-manager
+            
+            # Auto-inject home configurations
+            homeManagerConfig
+            
+            # Import all nixos modules recursively
+            ../${system}/${hostname}
+          ] ++ (extendedLib.mjallen.file.importModulesRecursive ../modules/nixos);
+        };
+      }
+    ) nixosSystems;
+    
+  # Example of creating home-manager configurations
+  homeConfigurations = 
+    let
+      # Get all homes
+      allHomes = inputs.self.mjallen-lib.file.scanHomes ../homes;
+    in
+    inputs.nixpkgs.lib.mapAttrs' (
+      name:
+      { system, username, hostname, userAtHost, path, ... }:
+      let
+        # Create extended lib with mjallen-lib
+        extendedLib = mkExtendedLib inputs.self inputs.nixpkgs;
+      in
+      {
+        name = userAtHost;
+        value = inputs.home-manager.lib.homeManagerConfiguration {
+          pkgs = import inputs.nixpkgs {
+            inherit system;
+            inherit ((mkNixpkgsConfig inputs.self)) config overlays;
+          };
+          
+          extraSpecialArgs = {
+            inherit inputs hostname username system;
+            inherit (inputs) self;
+            lib = extendedLib;
+          };
+          
+          modules = [
+            # Set lib to extended lib
+            { _module.args.lib = extendedLib; }
+            
+            # Import the home configuration
+            path
+          ] ++ (extendedLib.mjallen.file.importModulesRecursive ../modules/home);
+        };
+      }
+    ) allHomes;
+}