I havent tested this, but heres what i'd do for integrating git-hooks.nix:

{ src, lib, config, ... }: {
  options.git-hooks = {
    type = lib.types.attrs;
    default = { };
  };

  config = {
    withOverlays = [
      (final: prev: {
        pre-commit-check = final.inputs.git-hooks.lib.${final.system}.run
          ({ inherit src; } // config.git-hooks);
      })
    ];

    checks = pkgs: { inherit (pkgs) pre-commit-hook; };

    devShell = { pre-commit-check, ... }: {
      inherit (pre-commit-check) shellHook;
      packages = pre-commit-check.enabledPackages;
    };
  };
}

can put that as nix/flakelightModules/git-hooks.nix or w/e and import the module in your flakelight config. (or if you have many repos, put this in your common config one)

Then in a flake you can use it as such:

{
  inputs = {
    flakelight.url = "github:nix-community/flakelight";
    git-hooks.url = "github:cachix/git-hooks.nix";
  };
  outputs = { flakelight, ... }@inputs: flakelight ./. {
    inherit (inputs);
    # Pull it from file, outputs.flaklightModules.git-hooks,
    # inputs.shared-flake.flakelightModules.git-hooks, or w/e
    imports = [ ./git-hooks.nix ];

    git-hooks.hooks = {
      alejandra.enable = true;
      statix.enable = true;
      ruff-format.enable = true;
    }
  };
}

You'd even be able to autoload it as nix/git-hooks.nix:

{
  hooks = {
    alejandra.enable = true;
    statix.enable = true;
    ruff-format.enable = true;
  };
}

I havent tested this, but heres what i'd do for integrating git-hooks.nix:

{ src, lib, config, ... }: {
  options.git-hooks = {
    type = lib.types.attrs;
    default = { };
  };

  config = {
    withOverlays = [
      (final: prev: {
        pre-commit-check = final.inputs.git-hooks.lib.${final.system}.run
          ({ inherit src; } // config.git-hooks);
      })
    ];

    checks = pkgs: { inherit (pkgs) pre-commit-hook; };

    devShell = { pre-commit-check, ... }: {
      inherit (pre-commit-check) shellHook;
      packages = pre-commit-check.enabledPackages;
    };
  };
}

(note that it also doesnt go through outputs which requires resolving stuff...)

I havent tested this, but heres what i'd do for integrating git-hooks.nix:

{ src, lib, config, ... }: {
  options.git-hooks = {
    type = lib.types.attrs;
    default = { };
  };

  config = {
    withOverlays = [
      (final: prev: {
        pre-commit-check = final.inputs.git-hooks.lib.${final.system}.run
          ({ inherit src; } // config.git-hooks);
      })
    ];

    checks = pkgs: { inherit (pkgs) pre-commit-check; };

    devShell = { pre-commit-check, ... }: {
      inherit (pre-commit-check) shellHook;
      packages = pre-commit-check.enabledPackages;
    };
  };
}

(note that it also doesnt go through outputs which requires resolving stuff...)

Here is my script:

#!/usr/bin/env nu
# Generate a flamegraph from a nix flake evaluation
# Usage: script.nu <flake-path>

def main [flake_path: string] {
    print $"Evaluating flake: ($flake_path)"

    # Create temporary directory for profile data
    let tmp_dir = (mktemp -d)
    let profile_path = ($tmp_dir | path join "nix.profile")

    # Run nix eval with profiler output
    nix eval --impure --no-eval-cache $flake_path --option eval-profiler flamegraph --option eval-profile-file $profile_path

    # Generate flamegraph SVG from profile data
    open $profile_path | inferno-flamegraph | save -f flamegraph.svg

    print "Flamegraph saved to flamegraph.svg"
}

Here is my script:

#!/usr/bin/env nu
# Generate a flamegraph from a nix flake evaluation
# Usage: script.nu <flake-path>

def main [flake_path: string] {
    print $"Evaluating flake: ($flake_path)"

    # Create temporary directory for profile data
    let tmp_dir = (mktemp -d)
    let profile_path = ($tmp_dir | path join "nix.profile")

    # Run nix eval with profiler output
    nix eval --impure --no-eval-cache $flake_path --option eval-profiler flamegraph --option eval-profile-file $profile_path

    # Generate flamegraph SVG from profile data
    open $profile_path | inferno-flamegraph | save -f flamegraph.svg

    print "Flamegraph saved to flamegraph.svg"
}

Here is my Nushell script:

#!/usr/bin/env nu
# Generate a flamegraph from a nix flake evaluation
# Usage: script.nu <flake-path>

def main [flake_path: string] {
    print $"Evaluating flake: ($flake_path)"

    # Create temporary directory for profile data
    let tmp_dir = (mktemp -d)
    let profile_path = ($tmp_dir | path join "nix.profile")

    # Run nix eval with profiler output
    nix eval --impure --no-eval-cache $flake_path --option eval-profiler flamegraph --option eval-profile-file $profile_path

    # Generate flamegraph SVG from profile data
    open $profile_path | inferno-flamegraph | save -f flamegraph.svg

    print "Flamegraph saved to flamegraph.svg"
}

        checks = nix-config.checks;

error: The option `checks.<function body>' was accessed but has no value defined. Try setting the option.

checks = nix-config.checks;

error: The option `checks.<function body>' was accessed but has no value defined. Try setting the option.

interestingly, something like the following in nix/withOverlays/default.nix works:

final: prev: (prev.lib.composeManyExtensions [
  prev.inputs.nixgl.overlays.default
  prev.inputs.emacs-overlay.overlays.package
  prev.inputs.self.overlays.overrides
  prev.inputs.self.overlays.lix
]) final prev

So computing the module arguments is triggering evaluation of withOverlays... hmm

Does it make sense that this is supported?: (How does Flakelight know whether it is an overlay or a function to setup multiple overlays, like in my example ?)

withOverlays = overlay; 

Shouldn't it only support?:

withOverlays = [overlay, ...];