pub fn from_file(file: impl AsRef<Path>) -> anyhow::Result<Self> {

    Self::from_file_with_stack(file.as_ref(), &mut Vec::new())

  }

  fn from_file_with_stack(file: &Path, stack: &mut Vec<PathBuf>) -> anyhow::Result<Self> {

    let file_path = normalize_task_file_path(file)?;

    if let Some(index) = stack.iter().position(|path| path == &file_path) {

      let mut cycle = stack[index..]

        .iter()

        .map(|path| path.to_string_lossy().into_owned())

        .collect::<Vec<_>>();

      cycle.push(file_path.to_string_lossy().into_owned());

      anyhow::bail!("Circular extends detected: {}", cycle.join(" -> "));

    }

    stack.push(file_path.clone());

    let result = load_task_root(&file_path, stack);

    stack.pop();

    result

  }

  pub fn from_hashmap(tasks: HashMap<String, Task>) -> Self {

    Self {

      tasks,

      environment: HashMap::new(),

      env_file: Vec::new(),

      secrets_path: Vec::new(),

      secrets: None,

      vault_location: None,

      keys_location: None,

      key_name: None,

      gpg_key_id: None,

      use_npm: None,

      use_cargo: None,

      container_runtime: None,

      include: None,

      extends: None,

      source_path: None,

      raw_legacy_secret_settings: None,

      raw_secrets: None,

    }

  }

  pub fn config_base_dir(&self) -> PathBuf {

    self

      .source_path

      .as_ref()

      .and_then(|path| path.parent().map(Path::to_path_buf))

      .unwrap_or_else(|| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")))

  }

  pub fn cache_base_dir(&self) -> PathBuf {

    self.config_base_dir()

  }

  pub fn resolve_from_config(&self, value: &str) -> PathBuf {

    resolve_path(&self.config_base_dir(), value)

  }

  pub fn normalized_secret_settings(&self) -> Option<SecretSettings> {

    merge_optional_secret_settings(

      Some(SecretSettings::from_legacy(

        self.vault_location.clone(),

        self.keys_location.clone(),

        self.key_name.clone(),

        self.gpg_key_id.clone(),

        self.secrets_path.clone(),

      )),

      self.secrets.clone(),

    .filter(|settings| !settings.is_empty())

  }

  pub(crate) fn validation_legacy_secret_settings(&self) -> SecretSettings {

    self.raw_legacy_secret_settings.clone().unwrap_or_else(|| {

      SecretSettings::from_legacy(

        self.vault_location.clone(),

        self.keys_location.clone(),

        self.key_name.clone(),

        self.gpg_key_id.clone(),

        self.secrets_path.clone(),

    })

  }

  fn normalize_secret_settings(&mut self) {

    if self.raw_legacy_secret_settings.is_none() {

      self.raw_legacy_secret_settings = Some(SecretSettings::from_legacy(

        self.vault_location.clone(),

        self.keys_location.clone(),

        self.key_name.clone(),

        self.gpg_key_id.clone(),

        self.secrets_path.clone(),

      ));

    }

    if self.raw_secrets.is_none() {

      self.raw_secrets = self.secrets.clone();

    }

    self.secrets = self.normalized_secret_settings();

    if let Some(secrets) = &self.secrets {

      self.vault_location = secrets.vault_location.clone();

      self.keys_location = secrets.keys_location.clone();

      self.key_name = secrets.key_name.clone();

      self.gpg_key_id = secrets.gpg_key_id.clone();

      self.secrets_path = secrets.secrets_path.clone().unwrap_or_default();

    }

    for task in self.tasks.values_mut() {

      if let Task::Task(task) = task {

        task.normalize_secret_settings();

      }

  }

fn normalize_task_file_path(file: &Path) -> anyhow::Result<PathBuf> {

  let file_path = file

    .to_str()

    .and_then(expand_home_path)

    .unwrap_or_else(|| file.to_path_buf());

  if file_path.is_absolute() {

    Ok(file_path)

    Ok(std::env::current_dir()?.join(file_path))

}

fn load_task_root(file_path: &Path, stack: &mut Vec<PathBuf>) -> anyhow::Result<TaskRoot> {

  let file_extension = file_path

    .extension()

    .and_then(|ext| ext.to_str())

    .context("Failed to get file extension")?;

  let mut root = match file_extension {

    "yaml" | "yml" => load_yaml_file(file_path, stack),

  }?;

  if root.include.is_some() {

    anyhow::bail!("`include` is no longer supported. Use `extends` instead.");

  }

  root.normalize_secret_settings();

  root.source_path = Some(file_path.to_path_buf());

  process_task_sources(&mut root)?;

  Ok(root)

}

fn load_yaml_file(file: &Path, stack: &mut Vec<PathBuf>) -> anyhow::Result<TaskRoot> {

  let file_handle = File::open(file).with_context(|| {

  let reader = BufReader::new(file_handle);

  let mut value: serde_yaml::Value = serde_yaml::from_reader(reader)?;

  value.apply_merge()?;

  let root: TaskRoot = serde_yaml::from_value(value)?;

  apply_extends(file, stack, root)

}

fn process_task_sources(root: &mut TaskRoot) -> anyhow::Result<()> {

  root.tasks = rename_tasks(

    std::mem::take(&mut root.tasks),

    "task",

    &MK_COMMANDS,

    &HashMap::new(),

  if let Some(npm) = &root.use_npm {

  }

  if let Some(cargo) = &root.use_cargo {

    let cargo_tasks = cargo.capture_in_dir(&root.config_base_dir())?;

    let renamed_cargo_tasks = rename_tasks(cargo_tasks, "cargo", &MK_COMMANDS, &root.tasks);

    root.tasks.extend(renamed_cargo_tasks);

  }

  Ok(())

}

fn apply_extends(file: &Path, stack: &mut Vec<PathBuf>, mut root: TaskRoot) -> anyhow::Result<TaskRoot> {

  let Some(parent) = root.extends.clone() else {

    return Ok(root);

  let parent_path = file.parent().unwrap_or_else(|| Path::new(".")).join(parent);

  let mut base = TaskRoot::from_file_with_stack(&parent_path, stack)?;

  let base_secrets = base.normalized_secret_settings();

  let root_secrets = root.normalized_secret_settings();

  let merged_secrets =

    merge_optional_secret_settings(base_secrets.clone(), root_secrets.clone()).map(|mut secrets| {

      let mut merged_paths = base_secrets

        .as_ref()

        .and_then(|settings| settings.secrets_path.clone())

        .unwrap_or_default();

      if let Some(child_paths) = root_secrets.and_then(|settings| settings.secrets_path) {

      }

      if !merged_paths.is_empty() {

      }

      secrets

    });

  base.tasks.extend(root.tasks.drain());

  base.environment.extend(root.environment.drain());

  base.env_file.extend(root.env_file);

  base.secrets = merged_secrets;

  if let Some(secrets) = &base.secrets {

    base.vault_location = secrets.vault_location.clone();

    base.keys_location = secrets.keys_location.clone();

    base.key_name = secrets.key_name.clone();

    base.gpg_key_id = secrets.gpg_key_id.clone();

    base.secrets_path = secrets.secrets_path.clone().unwrap_or_default();

  }

  base.use_npm = root.use_npm.or(base.use_npm);

  base.use_cargo = root.use_cargo.or(base.use_cargo);

  base.container_runtime = root.container_runtime.or(base.container_runtime);

  base.include = root.include.or(base.include);

  base.extends = None;

  base.source_path = root.source_path.or(base.source_path);

  base.raw_legacy_secret_settings = None;

  base.raw_secrets = None;

  Ok(base)

}

fn get_lua_table(contents: &str) -> anyhow::Result<TaskRoot> {

  let lua = Lua::new();

  let value = lua.load(contents).eval()?;

  let root = lua.from_value(value)?;

  Ok(root)

}

fn rename_tasks(

  tasks: HashMap<String, Task>,

  prefix: &str,

  mk_commands: &[&str],

  existing_tasks: &HashMap<String, Task>,

) -> HashMap<String, Task> {

  let mut new_tasks = HashMap::new();

  for (task_name, task) in tasks.into_iter() {

    let new_task_name =

      if mk_commands.contains(&task_name.as_str()) || existing_tasks.contains_key(&task_name) {

        format!("{}_{}", prefix, task_name)

        task_name

    new_tasks.insert(new_task_name, task);

  new_tasks

}

  fn test_task_root_1() -> anyhow::Result<()> {

    let yaml = "

      tasks:

        task1:

          commands:

            - command: echo \"Hello, World 1!\"

              ignore_errors: false

              verbose: false

          depends_on:

            - name: task2

          description: 'This is a task'

          labels: {}

          environment:

            FOO: bar

          env_file:

            - test.env

        task2:

          commands:

            - command: echo \"Hello, World 2!\"

              ignore_errors: false

              verbose: false

          depends_on:

            - name: task1

          description: 'This is a task'

          labels: {}

          environment: {}

        task3:

          commands:

            - command: echo \"Hello, World 3!\"

              ignore_errors: false

              verbose: false

    ";

    let task_root = serde_yaml::from_str::<TaskRoot>(yaml)?;

    assert_eq!(task_root.tasks.len(), 3);

    if let Task::Task(task) = &task_root.tasks["task1"] {

      if let CommandRunner::LocalRun(local_run) = &task.commands[0] {

        assert_eq!(local_run.command, "echo \"Hello, World 1!\"");

        assert_eq!(local_run.work_dir, None);

        assert_eq!(local_run.ignore_errors, Some(false));

        assert_eq!(local_run.verbose, Some(false));

      if let TaskDependency::TaskDependency(args) = &task.depends_on[0] {

        assert_eq!(args.name, "task2");

      assert_eq!(task.labels.len(), 0);

      assert_eq!(task.description, "This is a task");

      assert_eq!(task.environment.len(), 1);

      assert_eq!(task.env_file.len(), 1);

    if let Task::Task(task) = &task_root.tasks["task2"] {

      if let CommandRunner::LocalRun(local_run) = &task.commands[0] {

        assert_eq!(local_run.command, "echo \"Hello, World 2!\"");

        assert_eq!(local_run.work_dir, None);

        assert_eq!(local_run.ignore_errors, Some(false));

        assert_eq!(local_run.verbose, Some(false));

      if let TaskDependency::TaskDependency(args) = &task.depends_on[0] {

        assert_eq!(args.name, "task1");

      assert_eq!(task.labels.len(), 0);

      assert_eq!(task.description, "This is a task");

      assert_eq!(task.environment.len(), 0);

      assert_eq!(task.env_file.len(), 0);

    if let Task::Task(task) = &task_root.tasks["task3"] {

      if let CommandRunner::LocalRun(local_run) = &task.commands[0] {

        assert_eq!(local_run.command, "echo \"Hello, World 3!\"");

        assert_eq!(local_run.work_dir, None);

        assert_eq!(local_run.ignore_errors, Some(false));

        assert_eq!(local_run.verbose, Some(false));

      assert_eq!(task.depends_on.len(), 0);

      assert_eq!(task.labels.len(), 0);

      assert_eq!(task.description.len(), 0);

      assert_eq!(task.environment.len(), 0);

      assert_eq!(task.env_file.len(), 0);

    Ok(())

  }

  fn test_task_root_2() -> anyhow::Result<()> {

    let yaml = "

      tasks:

        task1:

          commands:

            - command: echo \"Hello, World 1!\"

        task2:

          commands:

            - echo \"Hello, World 2!\"

        task3: echo \"Hello, World 3!\"

    ";

    let task_root = serde_yaml::from_str::<TaskRoot>(yaml)?;

    assert_eq!(task_root.tasks.len(), 3);

    if let Task::Task(task) = &task_root.tasks["task1"] {

      if let CommandRunner::LocalRun(local_run) = &task.commands[0] {

        assert_eq!(local_run.command, "echo \"Hello, World 1!\"");

        assert_eq!(local_run.work_dir, None);

        assert_eq!(local_run.ignore_errors, None);

        assert_eq!(local_run.verbose, None);

      assert_eq!(task.labels.len(), 0);

      assert_eq!(task.description, "");

      assert_eq!(task.environment.len(), 0);

      assert_eq!(task.env_file.len(), 0);

    if let Task::Task(task) = &task_root.tasks["task2"] {

      if let CommandRunner::CommandRun(command) = &task.commands[0] {

        assert_eq!(command, "echo \"Hello, World 2!\"");

      assert_eq!(task.labels.len(), 0);

      assert_eq!(task.description, "");

      assert_eq!(task.environment.len(), 0);

      assert_eq!(task.env_file.len(), 0);

    if let Task::String(command) = &task_root.tasks["task3"] {

      assert_eq!(command, "echo \"Hello, World 3!\"");

    Ok(())

  }

  fn test_task_root_secrets_config() -> anyhow::Result<()> {

    let yaml = "

      vault_location: ./.mk/vault

      keys_location: ./.mk/keys

      key_name: team

      secrets_path:

        - app/common

      tasks:

        demo:

          commands:

            - command: echo ready

    ";

    let task_root = serde_yaml::from_str::<TaskRoot>(yaml)?;

    let secrets = task_root.normalized_secret_settings().unwrap();

    assert_eq!(secrets.key_name.as_deref(), Some("team"));

    assert_eq!(task_root.secrets_path, vec!["app/common"]);

    assert_eq!(task_root.vault_location.as_deref(), Some("./.mk/vault"));

    assert_eq!(task_root.keys_location.as_deref(), Some("./.mk/keys"));

    assert_eq!(task_root.key_name.as_deref(), Some("team"));

    assert_eq!(task_root.gpg_key_id, None);

    Ok(())

  }

  fn test_task_root_gpg_key_id_deserialized() -> anyhow::Result<()> {

    let yaml = "

      gpg_key_id: 0xABCD1234EFGH5678

      tasks:

        demo:

          commands:

            - command: echo ready

    ";

    let task_root = serde_yaml::from_str::<TaskRoot>(yaml)?;

    assert_eq!(task_root.gpg_key_id.as_deref(), Some("0xABCD1234EFGH5678"));

    assert_eq!(

      task_root.normalized_secret_settings().unwrap().backend.as_ref(),

    Ok(())

  }

  fn test_task_root_secrets_block_deserialized() -> anyhow::Result<()> {

    let yaml = "

      secrets:

        backend: gpg

        vault_location: ./.mk/vault

        keys_location: ./.mk/keys

        key_name: team

        gpg_key_id: TEAMKEY

        secrets_path:

          - app/common

      tasks:

        demo:

          commands:

            - command: echo ready

    ";

    let task_root = serde_yaml::from_str::<TaskRoot>(yaml)?;

    let secrets = task_root.normalized_secret_settings().unwrap();

    assert_eq!(secrets.backend, Some(crate::secrets::SecretBackend::Gpg));

    assert_eq!(secrets.gpg_key_id.as_deref(), Some("TEAMKEY"));

    assert_eq!(secrets.vault_location.as_deref(), Some("./.mk/vault"));

    assert_eq!(secrets.secrets_path, Some(vec!["app/common".to_string()]));

    Ok(())

  }

  fn test_task_root_gpg_key_id_absent_defaults_to_none() -> anyhow::Result<()> {

    let yaml = "

      tasks:

        demo:

          commands:

            - command: echo ready

    ";

    let task_root = serde_yaml::from_str::<TaskRoot>(yaml)?;

    assert_eq!(task_root.gpg_key_id, None);

    Ok(())

  }

  fn test_task_root_apply_extends_gpg_key_id() -> anyhow::Result<()> {

    let dir = TempDir::new().unwrap();

    let parent_path = dir.path().join("parent.yaml");

    let child_path = dir.path().join("child.yaml");

    std::fs::write(&parent_path, "gpg_key_id: PARENT_KEY\ntasks:\n  dummy: echo ok\n")?;

    std::fs::write(

      &child_path,

    let root = TaskRoot::from_file(&child_path)?;

    assert_eq!(root.gpg_key_id.as_deref(), Some("PARENT_KEY"));

    Ok(())

  }

  fn test_task_root_apply_extends_child_gpg_key_id_overrides() -> anyhow::Result<()> {

    let dir = TempDir::new().unwrap();

    let parent_path = dir.path().join("parent.yaml");

    let child_path = dir.path().join("child.yaml");

    std::fs::write(&parent_path, "gpg_key_id: PARENT_KEY\ntasks:\n  dummy: echo ok\n")?;

    std::fs::write(

      &child_path,

    let root = TaskRoot::from_file(&child_path)?;

    assert_eq!(root.gpg_key_id.as_deref(), Some("CHILD_KEY"));

    Ok(())

  }

  fn test_task_root_3() -> anyhow::Result<()> {

    let yaml = "

      tasks:

        task1: echo \"Hello, World 1!\"

        task2: echo \"Hello, World 2!\"

        task3: echo \"Hello, World 3!\"

    ";

    let task_root = serde_yaml::from_str::<TaskRoot>(yaml)?;

    assert_eq!(task_root.tasks.len(), 3);

    if let Task::String(command) = &task_root.tasks["task1"] {

      assert_eq!(command, "echo \"Hello, World 1!\"");

    if let Task::String(command) = &task_root.tasks["task2"] {

      assert_eq!(command, "echo \"Hello, World 2!\"");

    if let Task::String(command) = &task_root.tasks["task3"] {

      assert_eq!(command, "echo \"Hello, World 3!\"");

    Ok(())

  }

  fn test_task_root_4() -> anyhow::Result<()> {

    let lua = "

      {

        tasks = {

          task1 = 'echo \"Hello, World 1!\"',

          task2 = 'echo \"Hello, World 2!\"',

          task3 = 'echo \"Hello, World 3!\"',

        }

      }

    ";

    let task_root = get_lua_table(lua)?;

    assert_eq!(task_root.tasks.len(), 3);

    if let Task::String(command) = &task_root.tasks["task1"] {

      assert_eq!(command, "echo \"Hello, World 1!\"");

    if let Task::String(command) = &task_root.tasks["task2"] {

      assert_eq!(command, "echo \"Hello, World 2!\"");

    if let Task::String(command) = &task_root.tasks["task3"] {

      assert_eq!(command, "echo \"Hello, World 3!\"");

    Ok(())

  }

  fn test_task_root_5_from_file_loads_use_cargo() -> anyhow::Result<()> {

    let temp_dir = TempDir::new()?;

    let config_path = temp_dir.path().join("tasks.yaml");

    fs::write(

      &config_path,

    let task_root = TaskRoot::from_file(&config_path)?;

    assert!(task_root.tasks.contains_key("test"));

    if let Task::Task(task) = &task_root.tasks["test"] {

      if let CommandRunner::LocalRun(local_run) = &task.commands[0] {

        assert_eq!(local_run.command, "cargo test");

        assert_eq!(

          Some(

            temp_dir

              .path()

              .join("crates")

              .join("app")

              .to_string_lossy()

              .into_owned()

          )

    Ok(())

  }

  fn test_task_root_6_from_file_rejects_include() -> anyhow::Result<()> {

    let temp_dir = TempDir::new()?;

    let config_path = temp_dir.path().join("tasks.yaml");

    fs::write(

      &config_path,

    let error = TaskRoot::from_file(&config_path).unwrap_err();

    assert!(error

      .to_string()

      .contains("`include` is no longer supported. Use `extends` instead."));

    Ok(())

  }

  fn test_task_root_7_from_file_rejects_extends_cycle() -> anyhow::Result<()> {

    let temp_dir = TempDir::new()?;

    let a_path = temp_dir.path().join("a.yaml");

    let b_path = temp_dir.path().join("b.yaml");

    fs::write(

      &a_path,

    fs::write(

      &b_path,

    let error = TaskRoot::from_file(&a_path).unwrap_err();

    assert!(error.to_string().contains("Circular extends detected:"));

    Ok(())

  }

  fn test_task_root_from_non_utf8_path() -> anyhow::Result<()> {

    let temp_dir = TempDir::new()?;

    let file_name = OsString::from_vec(vec![0x66, 0x6f, 0x80, 0x6f, 0x2e, 0x79, 0x61, 0x6d, 0x6c]);

    let config_path = temp_dir.path().join(file_name);

    std::fs::write(&config_path, "tasks:\n  hello: echo ok\n")?;

    let root = TaskRoot::from_file(&config_path)?;

    assert!(root.tasks.contains_key("hello"));

    Ok(())

  }