path: String,

  pub fn execute(&self, context: &Context) -> anyhow::Result<()> {

    let path: &str = &self.path.clone();

    let vault_location: &str = &self

      .vault_location

      .clone()

      .unwrap_or_else(|| context.vault_location());

    let keys_location: &str = &self

      .keys_location

      .clone()

      .unwrap_or_else(|| context.keys_location());

    let key_name: &str = &self.key_name.clone().unwrap_or_else(|| context.key_name());

    assert!(!path.is_empty(), "Path or prefix must be provided");

    assert!(!vault_location.is_empty(), "Vault location must be provided");

    assert!(!keys_location.is_empty(), "Keys location must be provided");

    assert!(!key_name.is_empty(), "Key name must be provided");

    verify_vault(vault_location)?;

    verify_key(keys_location, key_name)?;

    let key_name_with_ext = format!("{key_name}.key");

    let key_path = Path::new(keys_location).join(key_name_with_ext);

    let mut secret_key_string = File::open(key_path)?;

    let (signed_secret_key, _) = SignedSecretKey::from_armor_single(&mut secret_key_string)?;

    signed_secret_key.verify()?;

    let secret_path = Path::new(vault_location).join(path);

    let mut values = Vec::new();

    if secret_path.exists() && secret_path.is_dir() {

      let entries = fs::read_dir(secret_path.clone())?

        .filter_map(Result::ok)

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

      for entry in entries {

        let data_path = if entry.path().is_dir() {

          entry.path().join("data.asc")

          entry.path()

        if data_path.exists() && data_path.is_file() {

          let mut data_file = File::open(data_path)?;

          let (message, _) = Message::from_armor_single(&mut data_file)?;

          let (decrypted_message, _) = message.decrypt(String::new, &[&signed_secret_key])?;

          let value = decrypted_message

            .get_literal()

            .ok_or_else(|| anyhow::anyhow!("Secret value is not a literal"))?

            .to_string()

            .context("Failed to read secret value")?;

          values.push(value);

        }

      if values.is_empty() {

        println!("No secrets found for path: {}", path);

      } else {

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

          let mut output_file = File::create(output)?;

          for value in values {

            writeln!(output_file, "{}", value)?;

          output_file.flush()?;

          for value in values {

            println!("{}", value);

          }

    } else {

      println!("Path does not exist or is not a directory");

    }

    Ok(())

  }