dotfiles/modules/home/rsydn/devtools/ai-tools.nix

{ config, lib, pkgs, inputs, ... }:
let
  inherit (lib)
    mkEnableOption
    mkOption
    types
    mkIf
    concatMap
    unique
    warn
    escapeShellArg;
  cfg = config.rsydn.aiTools;

  nodePackages = if builtins.hasAttr "nodePackages_latest" pkgs then
    pkgs.nodePackages_latest
  else if builtins.hasAttr "nodePackages" pkgs then
    pkgs.nodePackages
  else
    { };

  hasNodePackage = name: builtins.hasAttr name nodePackages;
  getNodePackage = name:
    if hasNodePackage name then nodePackages.${name} else null;

  choosePackage = packages:
    let filtered = lib.filter (pkg: pkg != null) packages;
    in if filtered == [ ] then null else lib.head filtered;

  codexDefault = choosePackage [ (getNodePackage "@openai/codex") ];

  crushFromInput = if builtins.hasAttr "nix-ai-tools" inputs then
    let
      pkgSet = inputs."nix-ai-tools".packages or { };
      system = pkgs.stdenv.hostPlatform.system;
    in if builtins.hasAttr system pkgSet then
      let systemPackages = builtins.getAttr system pkgSet;
      in if builtins.hasAttr "crush" systemPackages then
        builtins.getAttr "crush" systemPackages
      else
        null
    else
      null
  else
    null;

  crushDefault =
    choosePackage [ crushFromInput (getNodePackage "@charmland/crush") ];

  opencodeDefault = choosePackage [ (getNodePackage "opencode-ai") ];

  claudeDefault =
    choosePackage [ (getNodePackage "@anthropic-ai/claude-code") ];

  toolOption =
    { name
    , description
    , defaultPackage
    , extraOptions ? { }
    , extraDefaults ? { }
    }:
    mkOption {
      type = types.submodule {
        options = {
          enable = mkOption {
            type = types.bool;
            default = true;
            description = "Enable the ${name} CLI.";
          };
          package = mkOption {
            type = types.nullOr types.package;
            default = defaultPackage;
            description =
              "Package providing ${name}. Set to null to skip installation.";
          };
        } // extraOptions;
      };
      default = {
        enable = true;
        package = defaultPackage;
      } // extraDefaults;
      description = description;
    };

  gatherToolPackages = tools:
    concatMap (tool:
      let
        name = tool.name;
        cfgTool = tool.cfg;
      in if cfgTool.enable then
        if cfgTool.package != null then
          [ cfgTool.package ]
        else
          warn "rsydn.aiTools.${name}: package is null, skipping install" [ ]
      else
        [ ]) tools;

  toolPackages = gatherToolPackages [
    {
      name = "codex";
      cfg = cfg.codex;
    }
    {
      name = "crush";
      cfg = cfg.crush;
    }
    {
      name = "opencode";
      cfg = cfg.opencode;
    }
    {
      name = "claude";
      cfg = cfg.claude;
    }
  ];

  zaiWrapperPackages =
    let
      claudeCfg = cfg.claude;
      zaiCfg = claudeCfg.zai or { enable = false; };
    in if claudeCfg.enable && zaiCfg.enable then
      if claudeCfg.package != null then
        let
          claudeExe = lib.getExe claudeCfg.package;
          commandName = zaiCfg.commandName;
          baseUrl = zaiCfg.baseUrl;
          model = zaiCfg.model;
          tokenEnvVar = zaiCfg.tokenEnvVar;
        in [
          (pkgs.writeShellApplication {
            name = commandName;
            text = ''
              if [ -z "''${${tokenEnvVar}:-}" ]; then
                echo "${commandName}: environment variable ${tokenEnvVar} is not set" >&2
                exit 1
              fi

              export ANTHROPIC_BASE_URL=${escapeShellArg baseUrl}
              export ANTHROPIC_AUTH_TOKEN="''${${tokenEnvVar}}"
              export ANTHROPIC_MODEL=${escapeShellArg model}

              exec ${claudeExe} "$@"
            '';
          })
        ]
      else
        warn "rsydn.aiTools.claude: Z.AI wrapper requested but package is null" [ ]
    else
      [ ];

in {
  options.rsydn.aiTools = {
    enable = mkEnableOption "AI-oriented command line tooling";

    codex = toolOption {
      name = "Codex";
      description = "OpenAI Codex CLI (npm @openai/codex).";
      defaultPackage = codexDefault;
    };

    crush = toolOption {
      name = "Crush";
      description = "Charmbracelet Crush CLI for natural language shell.";
      defaultPackage = crushDefault;
    };

    opencode = toolOption {
      name = "OpenCode";
      description = "OpenCode AI collaborative CLI.";
      defaultPackage = opencodeDefault;
    };

    claude = toolOption {
      name = "Claude Code";
      description = "Anthropic Claude Code CLI assistant.";
      defaultPackage = claudeDefault;
      extraOptions = {
        zai = mkOption {
          type = types.submodule {
            options = {
              enable = mkEnableOption
                "Expose the Z.AI Gateway wrapper command for Claude.";
              commandName = mkOption {
                type = types.str;
                default = "glm";
                description =
                  "Name of the wrapper command that launches Claude via Z.AI.";
              };
              baseUrl = mkOption {
                type = types.str;
                default = "https://api.z.ai/api/anthropic";
                description = "Gateway base URL used for the Anthropic client.";
              };
              model = mkOption {
                type = types.str;
                default = "glm-4.6";
                description = "Model identifier passed via ANTHROPIC_MODEL.";
              };
              tokenEnvVar = mkOption {
                type = types.str;
                default = "ZAI_API_KEY";
                description =
                  "Environment variable that stores the Z.AI API token.";
              };
            };
          };
          default = {
            enable = false;
            commandName = "glm";
            baseUrl = "https://api.z.ai/api/anthropic";
            model = "glm-4.6";
            tokenEnvVar = "ZAI_API_KEY";
          };
          description =
            "Configuration for the Claude wrapper that targets the Z.AI gateway.";
        };
      };
    };

    extraPackages = mkOption {
      type = types.listOf types.package;
      default = [ ];
      description =
        "Additional AI tooling packages to add alongside the defaults.";
    };
  };

  config = mkIf cfg.enable {
    home.packages = unique (toolPackages ++ zaiWrapperPackages ++ cfg.extraPackages);
  };
}