[jdx]

Summary

• When task files exist in mise-tasks/ but lack the executable bit (common when created on Windows and cloned on macOS/Linux), show a clear error with chmod +x instructions instead of the generic "no tasks defined" message
• Added warning to mise tasks ls when no tasks found but non-executable files exist in task directories
• Added e2e test covering both mise run and mise tasks cases

Closes #8614

Test plan

• mise run build with non-executable task files shows "non-executable" error with chmod +x suggestion
• mise tasks with non-executable task files shows warning about non-executable files
• After chmod +x, both mise tasks and mise run work correctly
• e2e test test_task_non_executable_error passes

🤖 Generated with Claude Code

---

Note

Low Risk
Low risk: changes are limited to error/warning messaging when no tasks are detected (non-Windows) plus a new e2e test; core task execution logic is unchanged.

Overview
Improves the "no tasks" failure path by detecting non-executable files in task include directories and surfacing a clearer error suggesting chmod +x (instead of the generic "no tasks defined" message).

Adds a warning in mise tasks ls when no tasks exist at all but non-executable task files are present (to avoid false positives from flag filtering), and introduces an e2e test verifying both the warning/error and the success case after making files executable.

^{Written by Cursor Bugbot for commit a363a40. This will update automatically on new commits. Configure here.}

[gemini-code-assist]

Summary of Changes

Hello, I'm Gemini Code Assist¹! I'm currently reviewing this pull request and will post my feedback shortly. In the meantime, here's a summary to help you and other reviewers quickly get up to speed!

This pull request significantly enhances the user experience for mise task management by providing more informative feedback when task files are not executable. Previously, users might encounter a generic "no tasks defined" error; now, the system intelligently detects non-executable task files and offers clear guidance, including chmod +x instructions, to resolve the issue. This change addresses a common problem, especially for users transferring files across different operating systems, and improves the discoverability and usability of tasks.

Highlights

• Improved Error Messaging: When mise run attempts to execute a task from a file that exists but lacks executable permissions, a clear error message is now displayed, including instructions to use chmod +x.
• Non-Executable File Warnings: The mise tasks ls command now issues a warning if no tasks are found but non-executable files are detected within the configured task directories, guiding users to make them executable.
• New End-to-End Test: An end-to-end test has been added to validate the new error messages and warnings for non-executable task files in both mise run and mise tasks scenarios.

Using Gemini Code Assist

The full guide for Gemini Code Assist can be found on our documentation page, here are some quick tips.

Invoking Gemini

You can request assistance from Gemini at any point by creating a comment using either /gemini <command> or @gemini-code-assist <command>. Below is a summary of the supported commands on the current page.

Feature	Command	Description
Code Review	/gemini review	Performs a code review for the current pull request in its current state.
Pull Request Summary	/gemini summary	Provides a summary of the current pull request in its current state.
Comment	@gemini-code-assist	Responds in comments when explicitly tagged, both in pull request comments and review comments.
Help	/gemini help	Displays a list of available commands.

Customization

To customize Gemini Code Assist for GitHub experience, repository maintainers can create a configuration file and/or provide a custom code review style guide (such as PEP-8 for Python) by creating and adding files to a .gemini/ folder in the base of the repository. Detailed instructions can be found here.

Limitations & Feedback

Gemini Code Assist may make mistakes. Please leave feedback on any instances where its feedback is incorrect or counter productive. You can react with 👍 and 👎 on @gemini-code-assist comments. If you're interested in giving your feedback about your experience with Gemini Code Assist for GitHub and other Google products, sign up here.

Footnotes

1. Review the Privacy Notices, Generative AI Prohibited Use Policy, Terms of Service, and learn how to configure Gemini Code Assist in GitHub here. Gemini can make mistakes, so double check it and use code with caution. ↩

[greptile-apps]

Greptile Summary

This PR improves the UX for a common Windows→macOS/Linux workflow issue: when task files exist in mise-tasks/ but lack the executable bit, mise now surfaces a clear error/warning with an explicit chmod +x suggestion instead of the opaque "no tasks defined" message.

Key changes:

• New shared helper find_non_executable_task_files extracted into task_list.rs, eliminating the duplicate walkdir traversal that existed in a prior iteration of this PR.
• err_no_task in task_list.rs gains a non-executable-file check (non-Windows only) that bails with a formatted error listing the count, directories, and up to 5 example paths.
• tasks ls in ls.rs now splits tasks into all_tasks (unfiltered) and tasks (after --global/--local/--hidden filters), so the non-executable warning only fires when there are truly zero tasks — not when a filter simply yields an empty subset.
• e2e test covers the complete lifecycle and validates both mise run and mise tasks output for "non-executable" and "chmod +x" strings.

Minor remaining polish item (not blocking): the space-joined file paths in the chmod +x example in task_list.rs are not quoted, so paths with spaces would produce a misleading shell command.

Confidence Score: 4/5

• Safe to merge — changes are confined to error/warning paths and an e2e test; no effect on normal task execution or discovery.
• The major concerns from previous review rounds (false-positive filter warning, duplicated walkdir logic, missing chmod +x in the e2e mise tasks assertion) have all been addressed. One small new style issue (unquoted paths in the chmod +x suggestion) remains, but it only affects the display of the error message in the unlikely event a task file name contains a space. No correctness or data-loss risk.
• No files require special attention; the path-quoting issue in src/task/task_list.rs is the only remaining item and is non-blocking.

Important Files Changed

Filename	Overview
src/task/task_list.rs	Adds find_non_executable_task_files shared helper and integrates it into err_no_task to produce an actionable chmod +x error; a few previously-flagged style issues (dirs_with_files scope, redundant CWD clone) remain unaddressed but don't affect correctness.
src/cli/tasks/ls.rs	Splits tasks into all_tasks/tasks to fix the false-positive warning when filters like --global/--local produce an empty result, and reuses the shared find_non_executable_task_files helper; warning message still omits specific file paths (flagged in a prior thread).
e2e/tasks/test_task_non_executable_error	New e2e test covers the full lifecycle (non-executable → helpful error → chmod → tasks work) and now checks for both "non-executable" and "chmod +x" strings in both mise run and mise tasks output.

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
    A[User runs mise run <task> or mise tasks] --> B{Tasks found?}
    B -- Yes --> C[Execute / list tasks normally]
    B -- No / empty --> D{Platform Windows?}
    D -- Yes --> E[Generic error: no tasks defined]
    D -- No --> F[find_non_executable_task_files]
    F --> G{Non-executable files exist in include dirs?}
    G -- No --> E
    G -- Yes --> H{Called from err_no_task?}
    H -- Yes, mise run --> I[bail! with count + dir list + chmod +x suggestion]
    H -- No, mise tasks ls --> J[warn! about non-executable files + chmod +x hint]

Loading

_{Reviews (5): Last reviewed commit: "fix(task): allow hidden root dirs like ...." | Re-trigger Greptile}

[gemini-code-assist]

Code Review

This pull request improves the user experience by providing a more informative error message when task files are not executable, which is a common issue for users moving between Windows and Unix-like systems. The changes include a new e2e test to cover this scenario, a warning in mise tasks ls, and a detailed error in mise run. The implementation is solid, but I've suggested a small refactoring to improve performance and code clarity in one of the new code blocks.

[gemini-code-assist]

This logic for finding non-executable files can be made more efficient and readable.

1. The iterator chain for finding non-executable files collects into a Vec for each subdirectory inside the flat_map, which is inefficient. This can be avoided by chaining iterators directly and letting the final collect do the work.
2. The bail! macro can use the cwd variable that is already in scope, which is a minor cleanup.

I've combined these improvements in the suggestion below.

Additionally, this logic is very similar to the one in src/cli/tasks/ls.rs. Consider extracting it into a shared helper function in a future refactoring to avoid code duplication.

                let non_exec_files: Vec<PathBuf> = includes
                    .iter()
                    .filter(|d| d.is_dir())
                    .flat_map(|d| {
                        walkdir::WalkDir::new(d)
                            .into_iter()
                            .filter_map(|e| e.ok())
                            .filter(|e| e.file_type().is_file() && !file::is_executable(e.path()))
                            .map(|e| e.path().to_path_buf())
                    })
                    .collect();
                if !non_exec_files.is_empty() {
                    let dirs_with_files: Vec<String> = includes
                        .iter()
                        .filter(|d| d.is_dir())
                        .map(|d| display_path(d))
                        .collect();
                    bail!(
                        "no tasks defined in {}, but found {} non-executable file(s) in {}.\n\
                        Files must be executable to be detected as tasks.\n\
                        Run `chmod +x` on the task files to fix this, e.g.:\n  chmod +x {}",
                        display_path(cwd),
                        non_exec_files.len(),
                        dirs_with_files.join(", "),
                        non_exec_files
                            .iter()
                            .take(5)
                            .map(|p| display_path(p))
                            .collect::<Vec<_>>()
                            .join(" "),
                    );

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

[greptile-apps]

Unquoted paths in chmod +x example

File paths are joined with a plain space: if any task file has a space in its name (e.g. mise-tasks/my build), the generated chmod +x command would be ambiguous and incorrect at the shell. Consider wrapping each path in double-quotes:

Suggested change

	non_exec_files
	.iter()
	.take(5)
	.map(display_path)
	.collect::<Vec<_>>()
	.join(" "),
	non_exec_files
	.iter()
	.take(5)
	.map(|p| format!("\"{}\"", display_path(p)))
	.collect::<Vec<_>>()
	.join(" "),

[github-actions]

Hyperfine Performance

mise x -- echo

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
mise-2026.3.10 x -- echo	18.9 ± 0.8	17.5	22.1	1.00
mise x -- echo	18.9 ± 0.6	17.7	24.2	1.00 ± 0.05

mise env

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
mise-2026.3.10 env	18.3 ± 0.7	17.1	23.2	1.00
mise env	19.5 ± 0.7	17.8	22.6	1.06 ± 0.06

mise hook-env

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
mise-2026.3.10 hook-env	20.7 ± 0.3	19.7	23.8	1.00
mise hook-env	21.3 ± 2.1	20.4	59.0	1.03 ± 0.10

mise ls

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
mise-2026.3.10 ls	19.4 ± 0.7	18.0	21.4	1.00 ± 0.05
mise ls	19.4 ± 0.6	17.8	21.5	1.00

xtasks/test/perf

Command	mise-2026.3.10	mise	Variance
install (cached)	116ms	114ms	+1%
ls (cached)	69ms	69ms	+0%
bin-paths (cached)	69ms	69ms	+0%
task-ls (cached)	746ms	718ms	+3%