misterdev 0.2.0__py3-none-any.whl

misterdev/task_executors/markdown_plan_executor/context_mixin.py

@@ -0,0 +1,221 @@
+"""Code-context assembly and MCP awareness/gathering."""
+
+from pathlib import Path
+from typing import List, Optional
+
+from misterdev.core.integration.mcp_gather import gather_context
+from misterdev.core.models import Task
+from misterdev.core.execution.project import Project
+from misterdev.config import get_setting
+
+from .helpers import logger, _relevant_line_ranges, _window_lines
+
+
+class ContextMixin:
+    def _mcp_gather(self, project: Project, task: Task) -> str:
+        """Run the bounded agentic MCP gathering loop, or "" when off.
+
+        Additive and behind ``orchestrator.mcp_tool_use`` (off by default): when
+        the flag is off, no MCP manager is configured, or discovery found no
+        tools, this returns "" so the task context — and the entire edit path —
+        is byte-for-byte unchanged from the no-MCP build. When on, the model may
+        request up to ``orchestrator.mcp_max_tool_rounds`` bounded MCP tool calls
+        (each via the timeout-guarded, never-raising ``MCPManager.call_tool``)
+        whose results are gathered into a context block. Never raises into the
+        build; any failure degrades to whatever was gathered so far.
+        """
+        if not get_setting(project.config, "orchestrator", "mcp_tool_use"):
+            return ""
+        mcp = getattr(project, "mcp", None)
+        local_tools = self._gather_safe_tools(project)
+        if mcp is None and not local_tools:
+            return ""
+        max_rounds = get_setting(project.config, "orchestrator", "mcp_max_tool_rounds")
+
+        def _ask(prompt: str) -> Optional[str]:
+            return project.llm_client.generate_code(prompt, "")
+
+        try:
+            return gather_context(
+                mcp,
+                _ask,
+                task_description=task.description,
+                max_rounds=max_rounds,
+                local_tools=local_tools,
+            )
+        except Exception as e:  # gathering is best-effort; never sink the build
+            logger.warning(f"MCP tool-gathering skipped (error: {e}).")
+            return ""
+
+    def _gather_safe_tools(self, project: Project) -> dict:
+        """Configured tools that opt into the gathering loop, as
+        ``{name: (description, call)}``.
+
+        A tool participates only if it is in ``project.config['tools']`` (operator
+        opted in) AND its class sets ``gather_safe = True`` — so a mutating tool
+        (command, file_io write/delete) is never exposed to this read-only
+        context-gathering pass; a plugin ships a read-only tool by declaring the
+        flag. Off by default: no built-in tool is gather-safe, so behaviour is
+        unchanged unless a gather-safe tool is configured.
+        """
+        import misterdev.tools  # noqa: F401 - registers built-in tools
+        from misterdev.plugins import TOOLS
+
+        local: dict = {}
+        for tc in project.config.get("tools") or []:
+            tool_cls = TOOLS.get(tc.get("type"))
+            if tool_cls is None or not getattr(tool_cls, "gather_safe", False):
+                continue
+            instance = tool_cls(tc)
+            name = tc.get("name") or tc.get("type")
+            desc = getattr(tool_cls, "gather_description", f"{tc.get('type')} tool")
+
+            def _call(args, _instance=instance):
+                ok, out = _instance.execute(project, **(args or {}))
+                return str(out) if ok else None
+
+            local[name] = (desc, _call)
+        return local
+
+    def _mcp_awareness(self, project: Project) -> str:
+        """Render the available-MCP-tools section, or "" when off / no tools.
+
+        Additive and behind ``orchestrator.mcp_enabled``: when the flag is off,
+        no MCP manager is configured, or discovery found nothing, this returns
+        an empty string so the task context is byte-for-byte unchanged from the
+        no-MCP build. It only informs the model the tools exist (awareness); it
+        does not enable the model to call them — that agentic loop is a separate,
+        out-of-scope phase that would drive ``project.mcp.call_tool``.
+        """
+        if not get_setting(project.config, "orchestrator", "mcp_enabled"):
+            return ""
+        mcp = getattr(project, "mcp", None)
+        if mcp is None:
+            return ""
+        described = mcp.describe_tools()
+        if not described:
+            return ""
+        return (
+            "\n\n## Available MCP tools (informational)\n"
+            "These external tools exist in this environment. You cannot invoke "
+            "them directly in your edits; they are listed so you understand what "
+            "capabilities are available.\n" + described
+        )
+
+    def _get_code_context(
+        self,
+        project: Project,
+        target_files: List[str],
+        context_files: List[str],
+        max_lines: int = 500,
+        task: Optional[Task] = None,
+    ) -> str:
+        context = ""
+        topo = getattr(project, "topography", None)
+        threshold = (
+            get_setting(project.config, "orchestrator", "large_file_line_threshold")
+            or 800
+        )
+        if target_files:
+            context += "### Files to Modify/Create\n"
+            for file_path in target_files:
+                context += self._render_target_file(
+                    project, topo, file_path, task, threshold
+                )
+        if context_files:
+            context += "\n### Reference/Context Files (Read-Only)\n"
+            for file_path in context_files:
+                context += self._read_file_for_context(
+                    project.path / file_path, file_path, max_lines
+                )
+        return context
+
+    def _fully_shown_target_files(
+        self, project: Project, target_files: List[str]
+    ) -> set:
+        """Target files small enough to be sent verbatim IN FULL by code_context.
+
+        These (existing files at or under the large-file threshold) have their
+        complete text in code_context, so topo can drop their own symbols to
+        avoid duplicating the same code across two sections. A large (windowed)
+        file is NOT included: its out-of-window symbols are still useful in topo.
+        """
+        threshold = (
+            get_setting(project.config, "orchestrator", "large_file_line_threshold")
+            or 800
+        )
+        shown = set()
+        for file_path in target_files:
+            full = project.path / file_path
+            try:
+                if full.exists() and full.stat().st_size:
+                    line_count = full.read_text(encoding="utf-8").count("\n") + 1
+                    if line_count <= threshold:
+                        shown.add(file_path)
+            except (UnicodeDecodeError, OSError):
+                continue
+        return shown
+
+    def _read_file_for_context(
+        self, full_path: Path, rel_path: str, max_lines: Optional[int]
+    ) -> str:
+        if not full_path.exists():
+            return f"\n# File: {rel_path} (Does not exist yet)\n"
+        try:
+            content = full_path.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError):
+            return f"\n# File: {rel_path} (binary or unreadable, skipped)\n"
+        lines = content.splitlines()
+        if max_lines is not None and len(lines) > max_lines:
+            content = (
+                "\n".join(lines[:max_lines])
+                + f"\n... ({len(lines)} lines total, truncated)"
+            )
+        return f"\n# File: {rel_path}\n{content}\n"
+
+    def _render_target_file(
+        self,
+        project: Project,
+        topo,
+        file_path: str,
+        task: Optional[Task],
+        threshold: int,
+    ) -> str:
+        """Render one target file for the edit prompt.
+
+        Small files are sent in full. Large files are sent as a symbol outline
+        plus verbatim windows of the task-relevant symbols (with elision markers
+        for the rest), so the model navigates via the outline and edits the
+        relevant regions exactly while context scales with the edit, not the
+        file. SEARCH/REPLACE still applies against the full on-disk content, so
+        windowing only narrows what the model reads, never what it can change.
+        """
+        full_path = project.path / file_path
+        outline = topo.get_file_outline(file_path) if topo is not None else ""
+        header = (
+            f"\n# Outline of {file_path} (symbol: line range):\n{outline}\n"
+            if outline
+            else ""
+        )
+        if not full_path.exists():
+            return header + f"\n# File: {file_path} (Does not exist yet)\n"
+        try:
+            content = full_path.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError):
+            return header + f"\n# File: {file_path} (binary or unreadable, skipped)\n"
+
+        lines = content.split("\n")
+        if topo is None or len(lines) <= threshold:
+            return header + f"\n# File: {file_path}\n{content}\n"
+
+        symbols = topo.get_file_symbols(file_path)
+        keep = _relevant_line_ranges(symbols, task, len(lines))
+        if keep is None:
+            # No symbol matched the task: never strand the model, send it all.
+            return header + f"\n# File: {file_path}\n{content}\n"
+        body = _window_lines(lines, keep)
+        return (
+            header
+            + f"\n# File: {file_path} (large file: windowed to relevant symbols; "
+            "use the outline above to locate anything not shown)\n" + f"{body}\n"
+        )

misterdev/task_executors/markdown_plan_executor/critic_spec_mixin.py

@@ -0,0 +1,174 @@
+"""Adversarial edit critic and spec-as-tests generation/execution."""
+
+import re
+import shlex
+from typing import Dict, List, Optional, Tuple
+
+from misterdev.core.models import Task
+from misterdev.core.execution.project import Project
+from misterdev.config import get_setting
+
+from .helpers import logger
+
+
+class CriticSpecMixin:
+    def _critic_enabled_for(self, project: Project, task: Task) -> bool:
+        """Whether the adversarial critic runs for this task.
+
+        ``adversarial_critic`` True/False forces it; "auto" (default) enables it
+        only for the cross-cutting categories in ``critic_auto_categories`` —
+        where symptom-fixes, incomplete refactors, and duplication cluster — so
+        the review runs out of the box on risky tasks without an extra call on
+        every trivial one.
+        """
+        setting = get_setting(project.config, "orchestrator", "adversarial_critic")
+        if isinstance(setting, str) and setting.strip().lower() == "auto":
+            categories = get_setting(
+                project.config, "orchestrator", "critic_auto_categories"
+            )
+            return getattr(task, "category", "") in (categories or [])
+        return bool(setting)
+
+    def _run_edit_critic(self, project: Project, task: Task, edits: Dict[str, str]):
+        """Run the independent adversarial critic over a candidate edit.
+
+        Reads the (optional) independent ``critic.model`` and timeout from config
+        and delegates to the never-raising, timeout-bounded gate. Returns a
+        :class:`~misterdev.core.verification.critic.CritiqueVerdict`; a SKIP
+        (no client, unparseable, timeout) is treated by the caller as "proceed".
+        """
+        from misterdev.core.verification.critic import run_edit_critic
+
+        critic_cfg = project.config.get("critic") or {}
+        timeout = get_setting(project.config, "orchestrator", "critic_timeout")
+        return run_edit_critic(
+            task.description,
+            task.acceptance_criteria,
+            edits,
+            llm_client=project.llm_client,
+            critic_model=critic_cfg.get("model"),
+            candidate_diffs=self._critic_diffs(project, edits),
+            panel=critic_cfg.get("panel", 1),
+            timeout=timeout,
+        )
+
+    @staticmethod
+    def _critic_diffs(project: Project, edits: Dict[str, str]) -> Dict[str, str]:
+        """Unified diff of each candidate edit vs its current on-disk content.
+
+        Lets the critic review WHAT CHANGED (with a little context) instead of
+        whole files — sharper and far smaller for a small edit to a large file.
+        A new file (no original) diffs against empty, i.e. all-additions. Reading
+        the original is best-effort: an unreadable file falls back to empty.
+        """
+        import difflib
+
+        diffs: Dict[str, str] = {}
+        for path, new_content in edits.items():
+            fp = project.path / path
+            try:
+                original = fp.read_text(encoding="utf-8") if fp.exists() else ""
+            except OSError:
+                original = ""
+            diff = "".join(
+                difflib.unified_diff(
+                    original.splitlines(keepends=True),
+                    (new_content or "").splitlines(keepends=True),
+                    fromfile=f"a/{path}",
+                    tofile=f"b/{path}",
+                )
+            )
+            diffs[path] = diff or "(no textual change)"
+        return diffs
+
+    def _maybe_generate_spec_test(self, project: Project, task: Task) -> Optional[str]:
+        """Generate + write a failing spec test for the task, or return None.
+
+        Off unless ``orchestrator.spec_as_tests`` and the task has acceptance
+        criteria. The test is written under ``.orchestrator/spec_tests/`` — NOT
+        the project's own test directory — so it is never collected by the
+        project suite and so cannot flip the integration-gate baseline red. Run
+        scoped later by :meth:`_run_spec_test`. Best-effort: any failure (no
+        client, model error, unwritable path) yields None.
+        """
+        if not get_setting(project.config, "orchestrator", "spec_as_tests"):
+            return None
+        if not getattr(task, "acceptance_criteria", ""):
+            return None
+        from misterdev.core.verification.spec_tests import (
+            generate_spec_test,
+        )
+
+        language = (project.config.get("language") or "python").lower()
+        try:
+            source = generate_spec_test(task, project.llm_client, language=language)
+        except Exception as e:  # generation is best-effort
+            logger.debug(f"Spec-test generation skipped: {e}")
+            return None
+        if not source:
+            return None
+        ext = {
+            "python": ".py",
+            "javascript": ".test.js",
+            "typescript": ".test.ts",
+        }.get(language, ".txt")
+        safe_id = re.sub(r"[^A-Za-z0-9_]", "_", str(getattr(task, "id", "task")))
+        path = project.path / ".orchestrator" / "spec_tests" / f"spec_{safe_id}{ext}"
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(source, encoding="utf-8")
+        except OSError as e:
+            logger.debug(f"Spec-test write skipped: {e}")
+            return None
+        logger.info(f"Spec-as-test written (run scoped after gates): {path}")
+        return str(path)
+
+    def _run_spec_test(
+        self, project: Project, spec_path: Optional[str], timeout: int
+    ) -> Tuple[str, str]:
+        """Run the generated spec test scoped to its file. Returns (status, detail).
+
+        ``status`` is ``green`` (passes — the spec is satisfied), ``red`` (still
+        fails), or ``skip`` (no spec test, or no scoped runner for this project's
+        language — we only run a single file for pytest/jest-style suites). Never
+        raises.
+        """
+        if not spec_path:
+            return "skip", ""
+        test_cmd = project.config.get("test_command") or ""
+        if "pytest" in test_cmd or spec_path.endswith(".py"):
+            runner = f"pytest -q {shlex.quote(spec_path)}"
+        elif "jest" in test_cmd:
+            runner = f"jest {shlex.quote(spec_path)}"
+        elif "vitest" in test_cmd:
+            runner = f"npx --yes vitest run {shlex.quote(spec_path)}"
+        elif "node --test" in test_cmd or spec_path.endswith(
+            (".test.ts", ".test.js", ".test.mjs")
+        ):
+            # Node's built-in runner strips TS at runtime, so a generated
+            # `.test.ts` spec runs with no extra toolchain — this is what makes
+            # TDD spec-as-tests work for a typecheck-only frontend target.
+            runner = f"node --test {shlex.quote(spec_path)}"
+        else:
+            return "skip", "no scoped spec-test runner for this project"
+        try:
+            ok, out = self._run_command(project, runner, timeout=timeout)
+        except Exception as e:  # a runner failure must not sink the task
+            logger.debug(f"Spec-test run skipped: {e}")
+            return "skip", ""
+        return ("green" if ok else "red"), out
+
+    @staticmethod
+    def _build_critic_error_context(objections: List[str]) -> str:
+        """Format critic objections into the same retry context shape as a gate.
+
+        The next attempt sees the concrete problems an independent reviewer found
+        in the rejected change and is told to address each before resubmitting.
+        """
+        listed = "\n".join(f"- {o}" for o in objections)
+        return (
+            "An independent reviewer rejected your previous change BEFORE it was "
+            "applied. Each objection below is a concrete defect — address every "
+            "one in your next attempt, then resubmit the corrected edit:\n"
+            f"{listed}"
+        )

misterdev/task_executors/markdown_plan_executor/edits_mixin.py

@@ -0,0 +1,251 @@
+"""Edit path validation, test-tamper detection, and edit application."""
+
+import re
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+from misterdev.core.models import Task
+from misterdev.core.execution.project import Project
+from misterdev.llm.responses import (
+    EditConflictError,
+    LLMResponseParser,
+    apply_search_replace,
+)
+from misterdev.config import get_setting
+from misterdev.utils.file_utils import write_file
+
+from .helpers import (
+    logger,
+    _is_golden_path,
+    _is_test_file,
+    _diagnose_py_tampering,
+    _diagnose_tampering,
+)
+
+
+class EditsMixin:
+    def _validate_edit_paths(
+        self, project: Project, task: Task, edits: Dict[str, str]
+    ) -> Dict[str, str]:
+        """Reject hallucinated or out-of-scope edits before they touch disk.
+
+        Drops edits that escape the project root (absolute paths, ``..``
+        traversal) or that would create empty files, and warns when the LLM
+        touches files outside the task's declared scope. This is what prevents
+        a misrouted edit from clobbering files outside the project.
+        """
+        project_root = project.path.resolve()
+        expected = set(task.files_to_modify + task.files_to_create)
+        golden_paths = get_setting(project.config, "orchestrator", "golden_paths")
+        valid: Dict[str, str] = {}
+        for path, content in edits.items():
+            if ".." in Path(path).parts or Path(path).is_absolute():
+                logger.error(f"Rejected edit with unsafe path: {path}")
+                continue
+            if _is_golden_path(path, golden_paths):
+                logger.error(f"Rejected edit to protected golden file: {path}")
+                continue
+            full = (project.path / path).resolve()
+            try:
+                inside = full.is_relative_to(project_root)
+            except ValueError:
+                inside = False
+            if not inside:
+                logger.error(f"Rejected edit to path outside project root: {path}")
+                continue
+            if not content.strip():
+                logger.warning(f"Rejected empty-content edit: {path}")
+                continue
+            if expected and path not in expected:
+                logger.warning(f"LLM modified file outside task scope: {path}")
+            valid[path] = content
+        return valid
+
+    def _detect_test_tampering(
+        self, project: Project, edits: Dict[str, str]
+    ) -> Optional[str]:
+        """Reject edits that weaken existing test files (deterministic gate).
+
+        For each edited TEST file that already exists on disk, compares the
+        current (pre-edit) content against the proposed content. An edit that
+        reduces tests/assertions or adds skip markers is tampering: the test
+        gate must not be satisfied by gutting the gate. New test files and
+        purely additive edits pass. Set ``orchestrator.allow_test_edits`` to
+        skip the check (escape hatch); it defaults to off (check enforced).
+        Must be called BEFORE ``_apply_edits`` so the on-disk content still
+        reflects the pre-edit state.
+        """
+        if get_setting(project.config, "orchestrator", "allow_test_edits"):
+            return None
+        reasons = []
+        for file_path, content in edits.items():
+            if not _is_test_file(file_path):
+                continue
+            full_path = project.path / file_path
+            if not full_path.exists():
+                continue
+            try:
+                before = full_path.read_text(encoding="utf-8")
+            except (UnicodeDecodeError, OSError):
+                continue
+            # Python uses precise assertion-survival diagnosis (resistant to
+            # rename/move/split/merge); other languages fall back to the
+            # cross-language regex totals, which can't parse structure.
+            if file_path.endswith((".py", ".pyi")):
+                reason = _diagnose_py_tampering(before, content)
+            else:
+                reason = _diagnose_tampering(before, content)
+            if reason:
+                reasons.append(f"{file_path} ({reason})")
+        return "; ".join(reasons) if reasons else None
+
+    def _detect_dangling_references(
+        self, project: Project, edits: Dict[str, str]
+    ) -> Optional[str]:
+        """Reject an edit that removes/renames a symbol but leaves its callers.
+
+        The whack-a-mole failure: an edit deletes or renames a symbol yet leaves
+        references in files it didn't touch, so the build fails one missed site
+        at a time until attempts run out. This catches it deterministically
+        BEFORE a build cycle: for every graph symbol defined in an edited file
+        whose name no longer appears in that file's new content (removed or
+        renamed), flag any caller — in a file NOT part of this edit — that still
+        references the old name on disk. Returns a description of the dangling
+        sites, or None when the change is complete. Graph-driven, so a coincidental
+        name match without a real reference edge is never flagged.
+        """
+        topo = getattr(project, "topography", None)
+        graph = getattr(topo, "graph", None)
+        symbols = getattr(graph, "symbols", None)
+        if not symbols:
+            return None
+        edited = set(edits.keys())
+        file_cache: Dict[str, str] = {}
+        dangling: list[str] = []
+        for sym in symbols.values():
+            if sym.file_path not in edited or not sym.incoming_calls:
+                continue
+            word = re.compile(rf"\b{re.escape(sym.name)}\b")
+            if word.search(edits.get(sym.file_path, "")):
+                continue  # symbol still defined in the edited file -> not removed
+            for caller_key in sym.incoming_calls:
+                caller = symbols.get(caller_key)
+                if caller is None or caller.file_path in edited:
+                    continue  # caller lives in a file this edit already changes
+                content = file_cache.get(caller.file_path)
+                if content is None:
+                    try:
+                        content = (project.path / caller.file_path).read_text(
+                            encoding="utf-8"
+                        )
+                    except (OSError, UnicodeDecodeError):
+                        content = ""
+                    file_cache[caller.file_path] = content
+                if word.search(content):
+                    dangling.append(
+                        f"`{sym.name}` still referenced in "
+                        f"{caller.file_path}:{caller.start_line}"
+                    )
+        if dangling:
+            return "; ".join(sorted(set(dangling))[:40])
+        return None
+
+    def _resolve_edits(
+        self, project: Project, llm_response: str
+    ) -> Tuple[Dict[str, str], Optional[str]]:
+        """Turn the LLM response into ``{path: full_content}`` edits.
+
+        Prefers surgical SEARCH/REPLACE hunks: each is applied against the
+        current on-disk file so the model never has to reproduce a large file
+        in full (the whole-file path truncates past the output-token limit).
+        The resolved full content then flows through the same path/syntax/
+        tamper gates as before. Returns ``(edits, error)``; a non-empty error
+        means a hunk did not apply and the attempt should retry rather than
+        write a partial file. Falls back to the whole-file parser when the
+        response contains no SEARCH/REPLACE markers.
+        """
+        sr_edits = LLMResponseParser.parse_search_replace_blocks(llm_response)
+        if not sr_edits:
+            return LLMResponseParser.parse_file_edits(llm_response), None
+        by_path: Dict[str, list] = {}
+        for edit in sr_edits:
+            by_path.setdefault(edit.path, []).append(edit)
+        resolved: Dict[str, str] = {}
+        for path, hunks in by_path.items():
+            full_path = project.path / path
+            try:
+                original = (
+                    full_path.read_text(encoding="utf-8") if full_path.exists() else ""
+                )
+            except (UnicodeDecodeError, OSError) as exc:
+                return {}, f"{path}: could not read file to apply edit ({exc})"
+            try:
+                resolved[path] = apply_search_replace(original, hunks)
+            except EditConflictError as exc:
+                return {}, str(exc)
+        return resolved, None
+
+    def _apply_edits(self, project: Project, edits: Dict[str, str]):
+        """Apply a batch of full-file edits atomically.
+
+        Writes are all-or-nothing: the pre-edit content of every file is
+        snapshotted first, and if any write raises, the already-written files
+        are rolled back to their snapshot (and newly-created files removed)
+        before the error propagates. Without this, a failure on file N left
+        files 1..N-1 written — a partial, inconsistent tree that only a
+        ``BudgetExceededError`` revert would clean up. Reuses ``write_file`` for
+        the writes rather than introducing a second write path.
+        """
+        snapshots: Dict[Path, Optional[str]] = {}
+        for file_path in edits:
+            full_path = project.path / file_path
+            try:
+                snapshots[full_path] = (
+                    full_path.read_text(encoding="utf-8")
+                    if full_path.exists()
+                    else None
+                )
+            except (UnicodeDecodeError, OSError):
+                # Unreadable pre-image (binary/permission): treat as "cannot
+                # safely roll back", so leave it out of the snapshot and let a
+                # failed write on it surface as-is.
+                snapshots[full_path] = None
+        written: list[Path] = []
+        try:
+            for file_path, content in edits.items():
+                full_path = project.path / file_path
+                write_file(full_path, content)
+                written.append(full_path)
+        except Exception:
+            for full_path in written:
+                original = snapshots.get(full_path)
+                try:
+                    if original is None:
+                        full_path.unlink(missing_ok=True)
+                    else:
+                        write_file(full_path, original)
+                except OSError as restore_err:
+                    logger.error(
+                        f"Failed to roll back {full_path} after a partial edit: "
+                        f"{restore_err}"
+                    )
+            raise
+
+    def _run_formatters(self, project: Project, files):
+        # Per-file formatters substitute {path}; project-wide formatters run
+        # once. Pass each file only to formatters whose command templates use
+        # {path}; otherwise invoke the formatter a single time.
+        file_list = list(files)
+        for tool_name, tool in project.tool_manager.tools.items():
+            if getattr(tool, "type", None) != "formatter":
+                continue
+            template = (
+                getattr(tool, "config", {}).get("command", "")
+                if hasattr(tool, "config")
+                else ""
+            )
+            if "{path}" in template:
+                for file_path in file_list:
+                    tool.execute(project, file_path=file_path)
+            else:
+                tool.execute(project)