minima-cli 0.4.9__py3-none-any.whl

minima_harness/minima/signals.py

@@ -0,0 +1,195 @@
+"""Code-quality signal extraction for code-aware routing (Phase B, the wedge).
+
+Minima's recall is otherwise text-similarity-based. Extracting lightweight, code-quality
+signals from the files a task touches and feeding them as ``tags`` / ``difficulty`` /
+``expected_input_tokens`` into ``recommend`` makes routing *code-aware* — the Triage-style
+wedge (route by CodeHealth + file metadata, not just prompt text).
+
+The default :class:`CodeHealthExtractor` is language-agnostic and dependency-free: a proxy
+McCabe (decision-keyword count), non-blank LOC, and sibling-test-file detection. It's a
+deliberately rough signal — precise, per-language complexity (radon/tree-sitter) can plug
+into the same :class:`ContextExtractor` protocol later. The discrimination gate
+(``tests/harness/test_signals.py``) is the falsifiable check that this signal separates
+task tiers at all; if it can't, code-aware routing isn't ready and we pivot to memory/cost.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+_log = logging.getLogger("minima_harness.signals")
+
+# Decision keywords across common languages (each ~ one McCabe branch). `and`/`or` cover
+# Python/Ruby/JS boolean ops; `&&`/`||` cover C-family. Word-boundary matches keep false
+# hits low (an identifier named "format" won't match "for").
+_DECISION_RE = re.compile(r"\b(if|elif|for|while|case|catch|except|switch|and|or|not)\b|&&|\|\|")
+
+# Files that look like tests (name conventions across languages).
+_TEST_NAME_RE = re.compile(
+    r"(^|[/_])(test_|_test\.|[a-z0-9_]+_test\.)|(tests?/)|(_spec\.|spec/)", re.IGNORECASE
+)
+
+# Approx tokens per non-blank source line (code is denser than prose).
+_TOKENS_PER_LOC = 10
+
+
+@dataclass(slots=True)
+class FileHealth:
+    path: str
+    loc: int
+    complexity: int
+
+
+@dataclass(slots=True)
+class SignalBundle:
+    """The enrichment handed to ``router.recommend``."""
+
+    tags: list[str] = field(default_factory=list)
+    difficulty: str | None = None
+    expected_input_tokens: int | None = None
+    # Raw signals (inspection / logging / the discrimination gate):
+    files: int = 0
+    total_loc: int = 0
+    max_file_loc: int = 0
+    total_complexity: int = 0
+    max_complexity: int = 0
+    avg_complexity: float = 0.0
+    has_tests: bool = False
+
+
+@runtime_checkable
+class ContextExtractor(Protocol):
+    async def extract(self, task: str, files: list[Path]) -> SignalBundle:
+        """Compute code-quality signals for ``files`` to enrich a recommendation."""
+        ...
+
+
+# extract() may be sync or async; normalize so callers can ``await`` either.
+ExtractFn = Callable[[str, list[Path]], Awaitable[SignalBundle] | SignalBundle]
+
+
+def _band(value: float, lo: float, hi: float) -> str:
+    if value <= lo:
+        return "low"
+    if value <= hi:
+        return "med"
+    return "high"
+
+
+class CodeHealthExtractor:
+    """Language-agnostic heuristic extractor (proxy McCabe + LOC + sibling tests)."""
+
+    def __init__(self, *, tokens_per_loc: int = _TOKENS_PER_LOC) -> None:
+        self._tokens_per_loc = tokens_per_loc
+
+    async def extract(self, task: str, files: list[Path]) -> SignalBundle:
+        per_file: list[FileHealth] = []
+        test_files: set[Path] = set()
+        all_paths = {f.resolve() for f in files}
+        for f in files:
+            try:
+                text = Path(f).read_text(encoding="utf-8", errors="replace")
+            except OSError as exc:
+                _log.debug("signal_skip_unreadable path=%s err=%s", f, exc)
+                continue
+            name = Path(f).name
+            is_test = bool(_TEST_NAME_RE.search(name)) or name.startswith("test")
+            fh = FileHealth(path=str(f), loc=_loc(text), complexity=_decisions(text))
+            if is_test:
+                test_files.add(Path(f).resolve())
+            per_file.append(fh)
+
+        source = [h for h in per_file if Path(h.path).resolve() not in test_files]
+        if not source:
+            source = per_file  # a pure test-edit task still gets signals
+
+        bundle = SignalBundle(
+            files=len(per_file),
+            total_loc=sum(h.loc for h in source),
+            max_file_loc=max((h.loc for h in source), default=0),
+            total_complexity=sum(h.complexity for h in source),
+            max_complexity=max((h.complexity for h in source), default=0),
+            has_tests=_has_tests(source, all_paths),
+        )
+        n = len(source) or 1
+        bundle.avg_complexity = bundle.total_complexity / n
+        bundle.difficulty = _difficulty(bundle)
+        bundle.expected_input_tokens = bundle.total_loc * self._tokens_per_loc
+        bundle.tags = _tags(bundle)
+        return bundle
+
+
+def _loc(text: str) -> int:
+    return sum(1 for line in text.splitlines() if line.strip())
+
+
+def _decisions(text: str) -> int:
+    return len(_DECISION_RE.findall(text))
+
+
+def _has_tests(source: list[FileHealth], all_paths: set[Path]) -> bool:
+    # A source file "has tests" if a test file is in the provided set, or a sibling test
+    # file exists on disk (test_<stem>.py / <stem>_test.py|go conventions).
+    if any(p for p in all_paths if _TEST_NAME_RE.search(p.name) or p.name.startswith("test")):
+        return True
+    for h in source:
+        stem = Path(h.path).stem
+        parent = Path(h.path).parent
+        for candidate in (
+            parent / f"test_{stem}.py",
+            parent / f"{stem}_test.py",
+            parent / f"{stem}_test.go",
+            parent / f"test_{stem}.go",
+        ):
+            if candidate.resolve() in all_paths or candidate.exists():
+                return True
+    return False
+
+
+def _difficulty(b: SignalBundle) -> str:
+    if b.max_file_loc > 800 or b.avg_complexity > 30:
+        return "expert"
+    if (
+        b.max_complexity >= 15
+        or b.max_file_loc > 400
+        or (not b.has_tests and b.avg_complexity > 10)
+    ):
+        return "hard"
+    if b.avg_complexity >= 5 or b.max_file_loc > 150:
+        return "medium"
+    if b.total_loc > 20:
+        return "easy"
+    return "trivial"
+
+
+def _tags(b: SignalBundle) -> list[str]:
+    return [
+        f"complexity:{_band(b.avg_complexity, 5, 15)}",
+        f"loc:{_band(float(b.max_file_loc), 150, 400)}",
+        "has_tests" if b.has_tests else "no_tests",
+        f"files:{b.files}",
+    ]
+
+
+async def extract_or_none(
+    extractor: ContextExtractor | None, task: str, files: list[Path] | None
+) -> SignalBundle | None:
+    """Run ``extractor`` if configured and files were provided; None otherwise.
+
+    Never raises — a broken extractor must not block routing (fall back to text-only).
+    """
+    if extractor is None or not files:
+        return None
+    try:
+        result = extractor.extract(task, list(files))
+        if hasattr(result, "__await__"):
+            result = await result  # type: ignore[assignment]
+        return result  # type: ignore[return-value]
+    except Exception:  # noqa: BLE001
+        _log.warning("signal_extraction_failed", exc_info=True)
+        return None

minima_harness/session/__init__.py

@@ -0,0 +1,14 @@
+"""Tree-structured JSONL session store (a port of PI's session model)."""
+
+from __future__ import annotations
+
+from minima_harness.session.format import EntryType, SessionEntry
+from minima_harness.session.store import SessionManager, SessionStore, SessionSummary
+
+__all__ = [
+    "EntryType",
+    "SessionEntry",
+    "SessionManager",
+    "SessionStore",
+    "SessionSummary",
+]

minima_harness/session/format.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import time
+import uuid
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+
+class EntryType(StrEnum):
+    USER = "user"
+    ASSISTANT = "assistant"
+    TOOL = "tool"
+    SYSTEM = "system"
+    GOAL = "goal"  # serialized Goal snapshot (latest wins); powers /goals across resume
+
+
+def new_id() -> str:
+    """A short, unique entry/session id (first 12 hex chars of uuid4)."""
+    return uuid.uuid4().hex[:12]
+
+
+def now_ts() -> float:
+    return time.time()
+
+
+class SessionEntry(BaseModel):
+    """One node in the session tree. Append-only; never mutated once written."""
+
+    id: str
+    parent_id: str | None = None
+    type: EntryType
+    ts: float = Field(default_factory=now_ts)
+    payload: dict
+    label: str | None = None  # optional bookmark label (for /tree)

minima_harness/session/store.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from minima_harness.session.format import EntryType, SessionEntry, new_id
+
+_log = logging.getLogger("minima_harness.session")
+
+
+def format_age(ts: float, now: float | None = None) -> str:
+    """Compact relative age for a timestamp: ``just now`` / ``5m ago`` / ``2h ago`` /
+    ``3d ago`` / ``5w ago``. Returns ``?`` when ``ts`` is missing/non-positive."""
+    if not ts or ts <= 0:
+        return "?"
+    now = time.time() if now is None else now
+    delta = max(0.0, now - ts)
+    if delta < 60:
+        return "just now"
+    if delta < 3600:
+        return f"{int(delta // 60)}m ago"
+    if delta < 86400:
+        return f"{int(delta // 3600)}h ago"
+    if delta < 86400 * 7:
+        return f"{int(delta // 86400)}d ago"
+    return f"{int(delta // (86400 * 7))}w ago"
+
+
+class SessionStore:
+    """Append-only JSONL session tree. File-backed or in-memory (``--no-session``)."""
+
+    def __init__(self, path: Path | None, *, display_name: str | None = None) -> None:
+        self._path = path
+        self._mem: list[SessionEntry] = []
+        self._tip: str | None = None
+        self.display_name = display_name
+        if path is not None and path.exists():
+            self._reload()
+
+    @classmethod
+    def file_backed(cls, path: Path, *, display_name: str | None = None) -> SessionStore:
+        return cls(path, display_name=display_name)
+
+    @classmethod
+    def in_memory(cls) -> SessionStore:
+        return cls(None)
+
+    @property
+    def path(self) -> Path | None:
+        return self._path
+
+    @property
+    def persistent(self) -> bool:
+        return self._path is not None
+
+    @property
+    def entries(self) -> list[SessionEntry]:
+        return list(self._mem)
+
+    @property
+    def tip(self) -> str | None:
+        return self._tip
+
+    def append(
+        self, entry_type: EntryType, payload: dict, *, label: str | None = None
+    ) -> SessionEntry:
+        entry = SessionEntry(
+            id=new_id(),
+            parent_id=self._tip,
+            type=entry_type,
+            payload=payload,
+            label=label,
+        )
+        self._mem.append(entry)
+        self._tip = entry.id
+        if self._path is not None:
+            try:
+                with self._path.open("a", encoding="utf-8") as fh:
+                    fh.write(entry.model_dump_json() + "\n")
+            except OSError:  # noqa: BLE001 - disk failure must not kill the turn
+                _log.warning("session_append_failed", exc_info=True)
+        return entry
+
+    def set_tip(self, entry_id: str) -> None:
+        """Branch: continue the next append from ``entry_id`` (must already exist)."""
+        if not any(e.id == entry_id for e in self._mem):
+            raise KeyError(f"unknown entry id: {entry_id}")
+        self._tip = entry_id
+
+    def path_to(self, entry_id: str) -> list[SessionEntry]:
+        """Root → entry_id path (inclusive). Raises KeyError if unknown."""
+        by_id = {e.id: e for e in self._mem}
+        if entry_id not in by_id:
+            raise KeyError(f"unknown entry id: {entry_id}")
+        out: list[SessionEntry] = []
+        cur: str | None = entry_id
+        while cur is not None and cur in by_id:
+            out.append(by_id[cur])
+            cur = by_id[cur].parent_id
+        out.reverse()
+        return out
+
+    def children_map(self) -> dict[str | None, list[str]]:
+        """parentId → child ids in insertion order (root key is None)."""
+        cm: dict[str | None, list[str]] = {}
+        for e in self._mem:
+            cm.setdefault(e.parent_id, []).append(e.id)
+        return cm
+
+    def _write_path(self, dest: Path, entries: list[SessionEntry]) -> None:
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        with dest.open("w", encoding="utf-8") as fh:
+            for e in entries:
+                fh.write(e.model_dump_json() + "\n")
+
+    def fork_to(self, dest: Path, *, from_entry_id: str) -> SessionStore:
+        """Copy the root→from_entry_id path into a new session file."""
+        path = self.path_to(from_entry_id)
+        self._write_path(dest, path)
+        return SessionStore.file_backed(dest)
+
+    def clone_to(self, dest: Path) -> SessionStore:
+        """Copy the current branch (root→tip) into a new session file."""
+        if self._tip is None:
+            self._write_path(dest, [])
+            return SessionStore.file_backed(dest)
+        return self.fork_to(dest, from_entry_id=self._tip)
+
+    def _reload(self) -> None:
+        assert self._path is not None
+        self._mem = []
+        for line in self._path.read_text(encoding="utf-8").splitlines():
+            if not line.strip():
+                continue
+            try:
+                self._mem.append(SessionEntry.model_validate_json(line))
+            except Exception:  # noqa: BLE001 - one bad line must not lose the session
+                _log.warning("session_skipped_malformed_line")
+        self._tip = self._mem[-1].id if self._mem else None
+
+
+@dataclass(slots=True)
+class SessionSummary:
+    session_id: str
+    path: Path
+    display_name: str | None
+    mtime: float  # file mtime ≈ last activity ("recently used")
+    n_entries: int
+    created: float = 0.0  # ts of the first entry ("created"); falls back to mtime
+
+
+class SessionManager:
+    """Discovers/creates session files under ``<sessions_dir>/<cwd-slug>/<uuid>.jsonl``."""
+
+    def __init__(self, sessions_dir: Path | None = None) -> None:
+        base = sessions_dir or Path.home() / ".minima-harness" / "sessions"
+        self._base = Path(base)
+
+    def slug_for(self, directory: Path) -> str:
+        directory = Path(directory).resolve()
+        slug = str(directory).replace(os.sep, "-").replace("/", "-")
+        return slug.lstrip("-") or "root"
+
+    def _dir_for(self, directory: Path) -> Path:
+        d = self._base / self.slug_for(directory)
+        d.mkdir(parents=True, exist_ok=True)
+        return d
+
+    def new(self, directory: Path, *, name: str | None = None) -> SessionStore:
+        sid = new_id()
+        path = self._dir_for(directory) / f"{sid}.jsonl"
+        return SessionStore.file_backed(path, display_name=name)
+
+    def open(
+        self,
+        directory: Path,
+        *,
+        session_id: str | None = None,
+        no_session: bool = False,
+    ) -> SessionStore:
+        if no_session:
+            return SessionStore.in_memory()
+        if session_id:
+            for s in self.list_sessions(directory):
+                if s.session_id.startswith(session_id) or session_id.startswith(s.session_id):
+                    return SessionStore.file_backed(s.path, display_name=s.display_name)
+            raise FileNotFoundError(f"no session matching id: {session_id}")
+        recent = self.most_recent(directory)
+        if recent is not None:
+            return SessionStore.file_backed(recent.path, display_name=recent.display_name)
+        return self.new(directory)
+
+    def most_recent(self, directory: Path) -> SessionSummary | None:
+        sessions = self.list_sessions(directory)
+        return max(sessions, key=lambda s: s.mtime) if sessions else None
+
+    def list_sessions(self, directory: Path) -> list[SessionSummary]:
+        d = self._base / self.slug_for(directory)
+        if not d.exists():
+            return []
+        out: list[SessionSummary] = []
+        for p in sorted(d.glob("*.jsonl")):
+            try:
+                nonempty = [ln for ln in p.read_text(encoding="utf-8").splitlines() if ln.strip()]
+            except OSError:  # noqa: BLE001
+                continue
+            mtime = p.stat().st_mtime
+            out.append(
+                SessionSummary(
+                    session_id=p.stem,
+                    path=p,
+                    display_name=None,
+                    mtime=mtime,
+                    n_entries=len(nonempty),
+                    created=_first_entry_ts(nonempty) or mtime,
+                )
+            )
+        # Most-recently-used first — the natural order for a resume picker.
+        out.sort(key=lambda s: s.mtime, reverse=True)
+        return out
+
+
+def _first_entry_ts(nonempty_lines: list[str]) -> float | None:
+    """Parse the ``ts`` of a session's first entry (its logical creation time)."""
+    if not nonempty_lines:
+        return None
+    try:
+        obj = json.loads(nonempty_lines[0])
+        ts = obj.get("ts") if isinstance(obj, dict) else None  # non-object first line → no ts
+        return float(ts) if ts is not None else None
+    except (ValueError, TypeError):
+        return None

minima_harness/tasks/__init__.py

@@ -0,0 +1,17 @@
+"""Task corpus + grading helpers for harness runs."""
+
+from minima_harness.tasks.task_set import (
+    PARTIAL_THRESHOLD,
+    SUCCESS_THRESHOLD,
+    TASKS,
+    Task,
+    grade_outcome,
+)
+
+__all__ = [
+    "PARTIAL_THRESHOLD",
+    "SUCCESS_THRESHOLD",
+    "TASKS",
+    "Task",
+    "grade_outcome",
+]

minima_harness/tasks/task_set.py

@@ -0,0 +1,78 @@
+"""Task corpus for harness runs.
+
+A :class:`Task` carries both the deterministic ``quality_fn`` (cheap, offline grading)
+and the richer ``rubric``/``expected`` fields the LLM judge consumes (Phase 3). Either
+grading path is optional: a task with ``quality_fn=None`` and an empty ``rubric`` just
+records tokens/cost with a neutral outcome.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+QualityFn = Callable[[str], float]
+
+
+@dataclass(slots=True)
+class Task:
+    """A single graded task."""
+
+    label: str
+    prompt: str
+    task_type: str  # code | qa | reasoning | extraction | creative | ...
+    quality_fn: QualityFn | None = None  # (model_output) -> float in [0, 1]
+    slider: float = 5.0  # cost/quality tradeoff: 1.0=cheapest, 10.0=best quality
+    rubric: str = ""  # consumed by the LLM judge (Phase 3)
+    expected: str = ""  # reference answer for the judge / deterministic checks
+    tags: list[str] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        assert 0.0 < self.slider <= 10.0, f"slider must be in (0, 10], got {self.slider}"
+
+
+# Outcome thresholds mirror examples/agent_warmup.py so feedback labels are consistent.
+SUCCESS_THRESHOLD = 0.8
+PARTIAL_THRESHOLD = 0.4
+
+
+def grade_outcome(quality: float) -> str:
+    """Map a [0, 1] quality score to a Minima outcome label."""
+    if quality >= SUCCESS_THRESHOLD:
+        return "success"
+    if quality >= PARTIAL_THRESHOLD:
+        return "partial"
+    return "failure"
+
+
+# ---------------------------------------------------------------------------
+# Seed corpus (3 tasks ported from the old agent/task_set.py, enriched)
+# ---------------------------------------------------------------------------
+
+TASKS: list[Task] = [
+    Task(
+        label="order-extract",
+        prompt="Extract order id and total from: 'Order #A-9931 totalling $48.20 shipped.'",
+        task_type="extraction",
+        quality_fn=lambda t: 1.0 if "A-9931" in t and "48.20" in t else 0.0,
+        slider=3.0,  # cheap is fine for extraction
+        rubric="Output must contain order id 'A-9931' and total '$48.20'.",
+        expected="A-9931, $48.20",
+    ),
+    Task(
+        label="retry-policy",
+        prompt=("Write a retry policy with jitter for a flaky payment webhook. Justify the math."),
+        task_type="reasoning",
+        quality_fn=lambda t: 0.9 if len(t) > 200 else 0.4,
+        slider=7.0,  # harder task, want quality
+        rubric="Must describe exponential backoff with jitter and justify the math.",
+    ),
+    Task(
+        label="binary-search",
+        prompt="Implement binary search in Python with a test. Make it idiomatic.",
+        task_type="code",
+        quality_fn=lambda t: 1.0 if "def binary_search" in t and "assert" in t else 0.5,
+        slider=5.0,
+        rubric="Must define `def binary_search(...)` and include an `assert`-based test.",
+    ),
+]

minima_harness/tools/__init__.py

@@ -0,0 +1,7 @@
+"""Built-in coding tools (read/write/edit/bash/grep/find/ls) — a port of PI's defaults."""
+
+from __future__ import annotations
+
+from minima_harness.tools.builtin import default_toolset
+
+__all__ = ["default_toolset"]

minima_harness/tools/_io.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+MAX_LINE = 2000
+
+
+def truncate_line(line: str) -> str:
+    if len(line) <= MAX_LINE:
+        return line
+    return line[:MAX_LINE] + " …(truncated)"
+
+
+def read_lines(path: Path, *, offset: int, limit: int) -> tuple[str, int]:
+    """Return (numbered_body, n_selected) for lines [offset, offset+limit)."""
+    text = path.read_text(encoding="utf-8", errors="replace")
+    lines = text.splitlines()
+    start = max(0, offset - 1)
+    end = min(len(lines), start + limit)
+    selected = lines[start:end]
+    width = len(str(end if end else 1))
+    body = "\n".join(
+        f"{str(i).rjust(width)}: {truncate_line(line)}"
+        for i, line in enumerate(selected, start=start + 1)
+    )
+    if end < len(lines):
+        body += f"\n…({len(lines) - end} more lines; use a larger offset to continue)"
+    return body, len(selected)
+
+
+def write_text(path: Path, content: str) -> int:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+    return len(content.splitlines())

minima_harness/tools/bash.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from minima_harness.agent.tools import AgentTool, ToolResult, ToolUpdate, error_result
+from minima_harness.ai.types import TextContent
+
+
+class BashParams(BaseModel):
+    command: str
+    timeout: int = Field(default=120_000, ge=1)  # milliseconds
+    workdir: str | None = None
+
+
+async def _execute(
+    tool_call_id: str,
+    params,
+    signal,
+    on_update: ToolUpdate | None,  # noqa: ANN001
+) -> ToolResult:
+    assert isinstance(params, BashParams)
+    wd = str(Path(params.workdir).expanduser()) if params.workdir else None
+    try:
+        proc = await asyncio.create_subprocess_shell(
+            params.command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+            cwd=wd,
+            start_new_session=True,
+        )
+    except OSError as exc:
+        return error_result(f"bash: failed to start: {exc}")
+
+    chunks: list[str] = []
+    assert proc.stdout is not None
+    try:
+        async with asyncio.timeout(params.timeout / 1000.0):
+            async for raw in proc.stdout:
+                chunk = raw.decode("utf-8", errors="replace")
+                chunks.append(chunk)
+                if on_update is not None:
+                    try:
+                        on_update(chunk)
+                    except Exception:  # noqa: BLE001 - progress must never break the run
+                        pass
+            await proc.wait()
+    except TimeoutError:
+        proc.kill()
+        await proc.wait()
+        return error_result(f"bash: timed out after {params.timeout} ms")
+
+    output = "".join(chunks)
+    code = proc.returncode if proc.returncode is not None else -1
+    body = f"{output}\n[exit {code}]" if output else f"[exit {code}]"
+    return ToolResult(content=[TextContent(text=body)], details={"exit_code": code})
+
+
+def bash_tool() -> AgentTool:
+    return AgentTool(
+        name="bash",
+        description=(
+            "Run a shell command and return its combined stdout/stderr and exit code. "
+            "Output streams live. Runs with the user's full permissions — no confirmation."
+        ),
+        parameters=BashParams,
+        execute=_execute,
+    )