flake.nix

{
  description = "user3301's dotfiles for native NixOS and NixOS WSL2";

  inputs = {
    # Nixpkgs - stable release
    nixpkgs.url = "github:nixos/nixpkgs/nixos-26.05";
    claude-code-nix = {
      url = "github:sadjow/claude-code-nix";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    # Herdr - terminal agent multiplexer (https://herdr.dev)
    herdr = {
      url = "github:ogulcancelik/herdr";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    # Home Manager - for user-level configuration
    home-manager = {
      url = "github:nix-community/home-manager/release-26.05";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    # NixOS WSL - for WSL2 support
    nixos-wsl = {
      url = "github:nix-community/NixOS-WSL";
      inputs.nixpkgs.follows = "nixpkgs";
    };

    # Pinned nixpkgs providing azure-cli 2.77.0 (nixpkgs went 2.75.0 -> 2.77.0
    # directly; 2.76.0 was never packaged). Deliberately not following the
    # main nixpkgs input, since the whole point is to freeze this one package.
    nixpkgs-azure-cli.url = "github:nixos/nixpkgs/286615174c6bd765907ef9975d0acdc799c7bf7e";
  };

  outputs =
    {
      self,
      nixpkgs,
      home-manager,
      nixos-wsl,
      ...
    }@inputs:
    let
      # The NixOS user, passed to the system modules as the `user` argument
      user = "user3301";

      supportedSystems = [
        "x86_64-linux"
        "aarch64-linux"
      ];
      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;

      claudeOverlay = inputs.claude-code-nix.overlays.default;

      # nixpkgs lags upstream copilot-cli releases; bump to the latest GitHub
      # release, using the platform tarballs since the universal one no longer
      # runs unpatched (see nixpkgs#534884 — drop once it lands)
      copilotOverlay = final: prev: {
        github-copilot-cli = prev.github-copilot-cli.overrideAttrs (
          finalAttrs: oldAttrs:
          let
            platform =
              {
                "x86_64-linux" = "linux-x64";
                "aarch64-linux" = "linux-arm64";
              }
              .${prev.stdenv.hostPlatform.system};
          in
          {
            version = "1.0.98";
            buildInputs = oldAttrs.buildInputs ++ [
              final.webkitgtk_4_1
              final.gtk3
              final.cairo
              final.gdk-pixbuf
              final.libsoup_3
              final.wayland
              final.dbus
              final.xdotool
            ];
            src = final.fetchurl {
              url = "https://github.com/github/copilot-cli/releases/download/v${finalAttrs.version}/github-copilot-${finalAttrs.version}-${platform}.tgz";
              hash =
                {
                  "x86_64-linux" = "sha256-pPX/6cooiGypsfiQFpmjpFZQJl27RzzBdXcsv8e4io8=";
                  "aarch64-linux" = "sha256-jAlbr0kiWueOUWMy1Qa4rQil2mD6pBu5OSXb1s4pkKc=";
                }
                .${prev.stdenv.hostPlatform.system};
            };
          }
        );
      };

      # roslyn.nvim requires a newer server than this channel provides.
      roslynOverlay =
        final: _prev:
        let
          recipe = final.fetchFromGitHub {
            owner = "NixOS";
            repo = "nixpkgs";
            rev = "ca0dc65018ebc2b7669325a31e2519c524866f81";
            hash = "sha256-147ZUA9Sqw17lyo+Fntiqv73Nu0c6IfVb/0ilcFcZYQ=";
          };
        in
        {
          roslyn-ls = final.callPackage "${recipe}/pkgs/by-name/ro/roslyn-ls/package.nix" { };
        };

      # azure-cli 2.77.0 (see nixpkgs-azure-cli input above) instead of
      # whatever version the main nixpkgs channel currently carries.
      azureCliOverlay = final: _prev: {
        inherit (import inputs.nixpkgs-azure-cli { inherit (final.stdenv.hostPlatform) system; })
          azure-cli
          ;
      };

      # Build an x86_64 NixOS host from the shared system settings, the host's
      # own modules, the package overlays, and the host's Home Manager config
      mkSystem =
        { modules, home }:
        nixpkgs.lib.nixosSystem {
          system = "x86_64-linux";
          modules = modules ++ [
            ./systems/common.nix
            home-manager.nixosModules.home-manager
            {
              nixpkgs.overlays = [
                claudeOverlay
                copilotOverlay
                roslynOverlay
                azureCliOverlay
              ];
              home-manager = {
                useGlobalPkgs = true;
                useUserPackages = true;
                users.${user} = home;
                extraSpecialArgs = { inherit inputs; };
              };
            }
          ];
          specialArgs = { inherit inputs user; };
        };

      wslModules = [
        nixos-wsl.nixosModules.wsl
        ./systems/wsl/configuration.nix
      ];

    in
    {
      # NixOS Configurations
      nixosConfigurations = {
        # One-time installer that clones the mutable dotfiles checkout before
        # Home Manager activates the same configuration as nixos-wsl.
        nixos-wsl-bootstrap = mkSystem {
          home = ./home/nixos-wsl.nix;
          modules = wslModules ++ [
            (
              { pkgs, ... }:
              {
                system.activationScripts.bootstrapDotfiles = {
                  deps = [ "users" ];
                  text = ''
                    target=/home/${user}/dotfiles
                    if [[ ! -e "$target" ]]; then
                      echo "cloning dotfiles into $target..."
                      ${pkgs.coreutils}/bin/install -d -o ${user} -g users /home/${user}
                      ${pkgs.util-linux}/bin/runuser -u ${user} -- \
                        ${pkgs.git}/bin/git clone \
                          https://github.com/user3301/dotfiles.git "$target"
                    elif [[ ! -d "$target/.git" ]]; then
                      echo "error: $target exists but is not a Git checkout" >&2
                      exit 1
                    fi
                  '';
                };
              }
            )
          ];
        };

        # NixOS WSL2 Configuration
        nixos-wsl = mkSystem {
          home = ./home/nixos-wsl.nix;
          modules = wslModules;
        };

        # Native NixOS Configuration
        nixos-native = mkSystem {
          home = ./home/nixos-native.nix;
          modules = [ ./systems/native/configuration.nix ];
        };
      };

      packages.x86_64-linux.bootstrap-wsl =
        let
          pkgs = nixpkgs.legacyPackages.x86_64-linux;
        in
        pkgs.writeShellApplication {
          name = "bootstrap-nixos-wsl";
          runtimeInputs = with pkgs; [
            gnugrep
          ];
          text = builtins.readFile ./scripts/bootstrap-nixos-wsl.sh;
        };

      apps.x86_64-linux.bootstrap-wsl = {
        type = "app";
        program = "${self.packages.x86_64-linux.bootstrap-wsl}/bin/bootstrap-nixos-wsl";
      };

      formatter = forAllSystems (system: nixpkgs.legacyPackages.${system}.nixfmt);

      checks = forAllSystems (
        system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
        in
        {
          nix-quality =
            pkgs.runCommand "nix-quality"
              {
                nativeBuildInputs = with pkgs; [
                  deadnix
                  findutils
                  nixfmt
                  statix
                ];
              }
              ''
                find ${self} -type f -name '*.nix' -print0 | xargs -0 nixfmt --check
                statix check ${self}
                deadnix --fail ${self}
                touch "$out"
              '';

          lua-format =
            pkgs.runCommand "lua-format"
              {
                nativeBuildInputs = [ pkgs.stylua ];
              }
              ''
                stylua \
                  --check \
                  --config-path ${self}/nvim/.config/nvim/stylua.toml \
                  ${self}/nvim/.config/nvim \
                  ${self}/wezterm/.config/wezterm
                touch "$out"
              '';

          zsh-syntax =
            pkgs.runCommand "zsh-syntax"
              {
                nativeBuildInputs = [ pkgs.zsh ];
              }
              ''
                zsh -n ${self}/zsh/.zshenv
                zsh -n ${self}/zsh/.zshrc
                touch "$out"
              '';

          bash-syntax =
            pkgs.runCommand "bash-syntax"
              {
                nativeBuildInputs = [ pkgs.bash ];
              }
              ''
                bash -n ${self}/bash/.bash_profile
                bash -n ${self}/bash/.bashrc
                touch "$out"
              '';
        }
      );

      # Development shell (optional but useful)
      devShells = forAllSystems (
        system:
        let
          pkgs = import nixpkgs { inherit system; };
        in
        {
          default = pkgs.mkShell {
            packages = with pkgs; [
              deadnix
              git
              nil # Nix LSP
              nixfmt
              statix
              stylua
              vim
              zsh
            ];
            shellHook = ''
              echo "Dotfiles development environment"
              echo "Use 'nixos-rebuild' to apply NixOS and Home Manager configurations"
            '';
          };
        }
      );
    };
}