Proposal: Support `Makefile` task

[kazupon]

Why?

In projects that are purely front-end, we can keep task management using npm scripts.

However, in monorepo projects that include back-end and infrastructure components, we often use Makefiles to set up development environments such as Docker containers.

When there are multiple ways to execute tasks, project developers can sometimes get confused. This lack of clarity is particularly challenging during onboarding when new developers join the team.

[ryoppippi]

we want to track "EVERY" task!!!!!!!

also i want to use justfile as well. we just need vite-task as more universal way to track tasks

[HaasStefan]

vite task currently only generates the task graph based on the workspace package graph. Knowing this current limitation, you could wrap your make commands in pnpm scripts or as a task in the vite.config.ts

[kazupon]

vite-task currently builds its task DAG entirely from the npm workspace package graph, workspace detection (pnpm-workspace.yaml / package.json workspaces), package discovery (package.json), and task sources (package.json scripts + vite-task.json) are all tightly coupled to the Node.js ecosystem.

I investigated whether vite-task can be able to support Makefile.

I've get the result which Supporting Makefile targets natively would require abstracting multiple layers (project detection, package units, task discovery, task sources, pre/post hooks), which is a significant architectural change.

Makefiles are fundamentally file-based build systems, targets are file paths, and execution is skipped when the target is newer than its prerequisites.

This is a different paradigm from vite-task's task runner model with fspy-based cache invalidation. Other Makefile-specific concerns include:

• Variable expansion ($(wildcard ...), $(shell ...)): static parsing can't resolve these, so the full task graph isn't discoverable without running Make itself
• Pattern rules / implicit rules (%.o: %.c): dynamically generated targets can't be enumerated by a parser
• Recipe execution model: each line runs in a separate shell (unlike vite-task's &&-chained commands)
• Parallel execution (make -j): would conflict with vite-task's own DAG scheduler

Rather than extending vite-task internals, the simplest and most practical approach is to convert Makefile targets into vite-task.json tasks using an external tool.
A Rust crate like makefile-lossless can parse .PHONY targets and their prerequisites, then generate a vite-task.json (vite.config.ts):

{
  "tasks": {
    "build": { "command": "make build", "dependsOn": ["setup"] },
    "test": { "command": "make test", "dependsOn": ["build"] },
    "clean": { "command": "make clean" }
  }
}

This way:

• Makefile tasks are tracked by vite-task (caching, dependency resolution, unified task list)
• No changes needed to vite-task's core architecture
• The same pattern works for justfile and other task sources mentioned in the comments
• .PHONY targets map naturally to vite-task tasks, while file-based targets are left to Make

This aligns with the suggestion to "wrap your make commands in pnpm scripts or as a task in the vite.config.ts", just automated via a converter tool.

[branchseer]

vite-task is deeply coupled with the npm ecosystem, so native Makefile/justfile support is out of scope for us. Keeping this open though, as we may explore plugin-based task discovery in the future.

[kazupon]

Makefile support using the vite plugin is here:
https://github.com/kazupon/vite-plugin-makefile

Caution

Note that this does not currently work. This is a proof-of-concept implementation in vp to support Makefile tasks via the vite plugin.