Completion and Parsing Issues with mise file tasks (var=#true)

[sassdavid]

Hi,

Recently, I started using mise file tasks more extensively with the usage specification. However, I have encountered some issues with task completion and general behavior. These might not be actual issues but rather a lack of knowledge or information about the intended usage.

Let’s assume we have the following task named demo:

#!/usr/bin/env bash

#MISE description="Demo"
#MISE alias="d"
#USAGE flag "-f --foo" var=#true help="Foo" {
#USAGE     arg <FOO>
#USAGE     choices "foo1" "foo2" "foo3" "foo4"
#USAGE }
#USAGE flag "-b --bar" help="Bar" {
#USAGE     arg <BAR>
#USAGE     choices "bar1" "bar2" "bar3" "bar4"
#USAGE }

set -exo pipefail

echo $usage_foo
echo $usage_bar

For the foo flag, I want to use var=#true and pass multiple values.

Issues:

1. Quiet Setting
   If I attempt to use the quiet setting, it doesn’t seem to work. I tried the following variations without success:

#MISE quiet=true
#MISE quiet=#true
#MISE quiet="true"

2. Behavior of -f --foo
   The following behaviors were observed for the -f --foo flag:

mise r d -f foo1
[demo] ERROR unexpected word: foo1
[demo] ERROR task failed

mise r d -- -f foo4
[demo] panic in task: panicked at /cargo/registry/src/index.crates.io-6f17d22bba15001f/usage-lib-2.0.3/src/parse.rs:126:22:
called `Option::unwrap()` on a `None` value

mise r d --foo foo4 -f foo3
[demo] panic in task: panicked at /cargo/registry/src/index.crates.io-6f17d22bba15001f/usage-lib-2.0.3/src/parse.rs:201:26:
called `Option::unwrap()` on a `None` value

mise r d --foo foo2 --foo foo1
[demo] $ ~/path/to/.mise-tasks/demo --foo foo2 --foo foo1
+ echo foo2 foo1
foo2 foo1
+ echo


mise r d -- --foo foo3
[demo] $ ~/path/to/.mise-tasks/demo --foo foo3
+ echo foo3
foo3
+ echo

Additionally, completion for -f --foo doesn’t work in certain cases:

mise r d -- -f <tab>
Error:
  × unexpected word: -f

mise     --    foo4

mise r d -- --foo <tab>
Error:
  × unexpected word: --foo

mise     --       foo3

3. Behavior of -b --bar
   For the -b --bar flag, the behavior is as follows:

mise r d -b bar1
[demo] $ ~/path/to/.mise-tasks/demo -b bar1
+ echo

+ echo bar1
bar1

mise r d -- -b bar2
[demo] $ ~/path/to/.mise-tasks/demo -b bar2
+ echo

+ echo bar2
bar2

mise r d --bar bar3
[demo] $ ~/path/to/.mise-tasks/demo --bar bar3
+ echo

+ echo bar3
bar3

mise r d -- --bar bar4
[demo] $ ~/path/to/.mise-tasks/demo --bar bar4
+ echo

+ echo bar4
bar4

Completion also has issues with -b --bar, but only after --. Without --, the completion works as expected (for -f --foo as well):

mise r d -b bar3<tab>
bar1  bar2  bar3  bar4

mise r d --foo foo2<tab>
foo1  foo2  foo3  foo4

Analysis

It seems that the var=#true setting might influence the behavior. However, I am not sure if this is a bug in the usage library or if it is the intended behavior.

Could you please help me understand these behaviors? Are these bugs in usage, or is this the expected behavior? Any guidance would be greatly appreciated.

Thank you in advance for your help!

mise version: 2025.1.14 linux-x64 (daa75da 2025-01-24)
usage version: usage-cli 2.0.3

[uasi]

Quiet Setting

The #MISE directive expects TOML syntax, unlike the #USAGE directive, which uses KDL. So, it should be written as #MISE quiet=true. Unfortunately, it seems that the task parser currently lacks support for certain settings, including quiet:

mise/src/task/mod.rs

Lines 149 to 196 in 31bd9ba

	pub fn from_path(path: &Path, prefix: &Path, config_root: &Path) -> Result<Task> {
	let mut task = Task::new(path, prefix, config_root)?;
	let info = file::read_to_string(path)?
	.lines()
	.filter_map(|line| {
	regex!(r"^(#|//) mise ([a-z_]+=.+)$")
	.captures(line)
	.or_else(|| regex!(r"^(#|//|::)MISE ([a-z_]+=.+)$").captures(line))
	})
	.map(|captures| captures.extract().1)
	.flat_map(|[_, toml]| {
	toml.parse::<toml::Value>()
	.map_err(|e| debug!("failed to parse toml: {e}"))
	})
	.filter_map(|toml| toml.as_table().cloned())
	.flatten()
	.fold(toml::Table::new(), |mut map, (key, value)| {
	map.insert(key, value);
	map
	});
	let info = toml::Value::Table(info);
	let p = TomlParser::new(&info);
	// trace!("task info: {:#?}", info);
	task.hide = !file::is_executable(path) || p.parse_bool("hide").unwrap_or_default();
	task.aliases = p
	.parse_array("alias")
	.or(p.parse_array("aliases"))
	.or(p.parse_str("alias").map(|s| vec![s]))
	.or(p.parse_str("aliases").map(|s| vec![s]))
	.unwrap_or_default();
	task.description = p.parse_str("description").unwrap_or_default();
	task.sources = p.parse_array("sources").unwrap_or_default();
	task.outputs = info.get("outputs").map(|to| to.into()).unwrap_or_default();
	task.depends = p.parse_array("depends").unwrap_or_default();
	task.depends_post = p.parse_array("depends_post").unwrap_or_default();
	task.wait_for = p.parse_array("wait_for").unwrap_or_default();
	task.dir = p.parse_str("dir");
	task.env = p.parse_env("env")?.unwrap_or_default();
	task.file = Some(path.to_path_buf());
	task.shell = p.parse_str("shell");
	task.tools = p
	.parse_table("tools")
	.map(|t| t.into_iter().map(|(k, v)| (k, v.to_string())).collect())
	.unwrap_or_default();
	task.render(config_root)?;
	Ok(task)
	}

Behavior of -f --foo

It seems that using var=true fixes that behavior. I suspect this might be related to the recent release of KDL v2, which changed the boolean literal from true to #true. It appears that usage seamlessly supports both versions of KDL, but there might be some issue with that.

[sassdavid]

Thanks for the reply.
It seems like quiet is most likely not supported at the moment.

Regarding the other issue, I encountered a KDL parsing error when trying to use var=true.

mise r d -v
DEBUG ARGS: /home/sassd/.local/bin/mise r d -v
DEBUG config: ~/path/to/mise.toml
DEBUG config: ~/.config/mise/config.toml
DEBUG read_to_string: "/path/to/.mise-tasks/demo"
DEBUG failed to parse task file with usage: Failed to parse KDL document
[demo] $ ~/path/to/.mise-tasks/demo
DEBUG $ ~/path/to/.mise-tasks/demo
+ echo

+ echo

Interestingly, it doesn't display the exact error message. I also tested it with my real task, and in that case, I received a proper parsing error message:

...
DEBUG failed to parse task file with usage: Failed to parse KDL document
[tg_run_all_command] $ ~/path/to/.mise-tasks/tg_run_all_command
DEBUG $ ~/path/to/.mise-tasks/tg_run_all_command

  × Failed to parse KDL document

Error:
  × Expected identifier string
   ╭─[1:32]
 1 │ flag "-d --tg-include-dir" var=true help="Specify directories (modules) to include in the Terragrunt run-all command" {
   ·                                ──┬─
   ·                                  ╰── not identifier string
 2 │ arg <TG_INCLUDE_DIR>
   ╰────

[tg_run_all_command] ERROR task failed
DEBUG exiting with code: 181

[uasi]

I encountered a KDL parsing error when trying to use var=true.

Ah yes, you're right. Looks like I got it wrong.