execsql2 2.18.0__py3-none-any.whl → 2.18.1__py3-none-any.whl

execsql/cli/__init__.py

@@ -8,8 +8,7 @@ Submodules:
 - :mod:`execsql.cli.help`      — Rich-formatted help output & console objects
 - :mod:`execsql.cli.dsn`       — Connection-string (DSN URL) parser
 - :mod:`execsql.cli.run`       — Core execution logic (``_run``, ``_connect_initial_db``, ``_ping_db``, ``_print_dry_run``, ``_print_profile``)
-- :mod:`execsql.cli.lint_ast`  — AST-based ``--lint`` static analyser
-- :mod:`execsql.cli.lint`      — Shared lint result printing (``_print_lint_results``) used by the AST linter
+- :mod:`execsql.cli.lint`      — AST-based ``--lint`` static analyser and Rich result printer
 """
 
 from __future__ import annotations
@@ -554,8 +553,7 @@ def main(
     # Lint: AST-based static analysis (no DB connection needed)
     # ------------------------------------------------------------------
     if lint:
-        from execsql.cli.lint import _print_lint_results
-        from execsql.cli.lint_ast import lint_ast
+        from execsql.cli.lint import _print_lint_results, lint as _lint_script
         from execsql.script.parser import parse_script, parse_string
 
         label = script_name or "<inline>"
@@ -576,7 +574,7 @@ def main(
             exit_code = _print_lint_results(issues, label)
             raise typer.Exit(code=exit_code) from exc
 
-        issues = lint_ast(tree, script_path=script_name)
+        issues = _lint_script(tree, script_path=script_name)
         exit_code = _print_lint_results(issues, label)
         raise typer.Exit(code=exit_code)
 

execsql/cli/lint.py

@@ -1,30 +1,63 @@
-"""Shared Rich-formatted output for ``--lint`` results.
+"""AST-based static analysis (``--lint``) for execsql scripts.
 
-The active linter is :mod:`execsql.cli.lint_ast`, which produces
-``(severity, source, line_no, message)`` tuples. This module owns the
-small surface that converts those tuples into the user-facing console
-output:
+Operates on the :class:`~execsql.script.ast.Script` tree produced by
+:func:`execsql.script.parser.parse_script` / ``parse_string``. Runs as
+an early CLI exit — no DB connection and no ``_state`` initialisation
+required.
 
-- :class:`_Issue` — the issue tuple type alias.
-- :func:`_error` / :func:`_warning` — issue constructors.
-- :func:`_print_lint_results` — Rich console formatter; returns the
-  ``--lint`` exit code (``1`` if any error, else ``0``).
+Checks performed:
 
-This module previously hosted a flat-CommandList walker
-(``_lint_script`` / ``_lint_cmdlist`` and friends) that pre-dated the
-AST. The walker was removed once the CLI fully migrated to the AST
-linter; the rename of ``_state.savedscripts`` → ``_state.ast_scripts``
-had silently turned its EXECUTE-SCRIPT flow analysis into a no-op.
+1. **Parse errors** — the AST parser rejects unmatched IF / LOOP /
+   BATCH / SCRIPT blocks at parse time with precise source spans;
+   ``cli/__init__.py`` reports any parse failure as a lint error before
+   :func:`lint` is even called.
+2. **Empty scripts** — warns when no nodes were parsed.
+3. **Potentially undefined variables** — flags ``!!$VAR!!`` references
+   with no preceding ``SUB``-family definition, ignoring built-in
+   ``$VAR`` names discovered from the package source and the
+   non-``$`` sigils (``~``, ``#``, ``+``, ``@``, ``&``) that resolve at
+   runtime.
+4. **Missing INCLUDE files** — warns when the resolved target does not
+   exist on disk (skipped when ``IF EXISTS`` is present).
+5. **EXECUTE SCRIPT target resolution** — warns when a target name does
+   not correspond to a :class:`ScriptBlock` in the same file (skipped
+   when ``IF EXISTS`` is present).
 
-Exit-code contract (honoured by the AST linter):
+Public surface:
 
-- ``1`` when at least one error-severity issue is found.
-- ``0`` when only warnings (or nothing) are found.
+- :func:`lint` — entry point; returns a list of
+  ``(severity, source, line_no, message)`` tuples.
+- :func:`_print_lint_results` — Rich console formatter for those
+  tuples; returns the ``--lint`` process exit code (``1`` when any
+  error-severity issue is present, ``0`` otherwise).
+- :data:`_Issue`, :func:`_error`, :func:`_warning` — tuple type alias
+  and constructors used by the walker and the formatter.
 """
 
 from __future__ import annotations
 
-__all__ = ["_Issue", "_error", "_print_lint_results", "_warning"]
+import re
+from pathlib import Path
+
+from execsql.script.ast import (
+    BatchBlock,
+    IfBlock,
+    IncludeDirective,
+    LoopBlock,
+    MetaCommandStatement,
+    Node,
+    Script,
+    ScriptBlock,
+    SqlBlock,
+    SqlStatement,
+)
+
+__all__ = ["_Issue", "_error", "_print_lint_results", "_warning", "lint"]
+
+
+# ---------------------------------------------------------------------------
+# Issue tuple type and constructors
+# ---------------------------------------------------------------------------
 
 
 _Issue = tuple[str, str, int, str]  # (severity, source, line_no, message)
@@ -38,6 +71,388 @@ def _warning(source: str, line_no: int, message: str) -> _Issue:
     return ("warning", source, line_no, message)
 
 
+# ---------------------------------------------------------------------------
+# Variable-related patterns
+# ---------------------------------------------------------------------------
+
+_RX_SUB = re.compile(r"^\s*SUB\s+(?P<name>[+~]?\w+)\s+", re.I)
+_RX_SUB_EMPTY = re.compile(r"^\s*SUB_EMPTY\s+(?P<name>[+~]?\w+)\s*$", re.I)
+_RX_SUB_ADD = re.compile(r"^\s*SUB_ADD\s+(?P<name>[+~]?\w+)\s+", re.I)
+_RX_SUB_APPEND = re.compile(r"^\s*SUB_APPEND\s+(?P<name>[+~]?\w+)\s", re.I)
+_RX_SUBDATA = re.compile(r"^\s*SUBDATA\s+(?P<name>[+~]?\w+)\s+", re.I)
+_RX_SUB_INI = re.compile(
+    r'^\s*SUB_INI\s+(?:FILE\s+)?(?:"(?P<qfile>[^"]+)"|(?P<file>\S+))'
+    r"(?:\s+SECTION)?\s+(?P<section>\w+)\s*$",
+    re.I,
+)
+_RX_SELECTSUB = re.compile(r"^\s*(?:SELECT_?SUB|PROMPT\s+SELECT_?SUB)\s+", re.I)
+_RX_SUB_LOCAL = re.compile(r"^\s*SUB_LOCAL\s+(?P<name>\w+)\s+", re.I)
+_RX_SUB_TEMPFILE = re.compile(r"^\s*SUB_TEMPFILE\s+(?P<name>\w+)\s", re.I)
+_RX_SUB_DECRYPT = re.compile(r"^\s*SUB_DECRYPT\s+(?P<name>\w+)\s+", re.I)
+_RX_SUB_ENCRYPT = re.compile(r"^\s*SUB_ENCRYPT\s+(?P<name>\w+)\s+", re.I)
+_RX_SUB_QUERYSTRING = re.compile(r"^\s*SUB_QUERYSTRING\s+(?P<name>\w+)\s+", re.I)
+
+_RX_VAR_REF = re.compile(r"!!([$@&~#+]?\w+)!!", re.I)
+
+
+# ---------------------------------------------------------------------------
+# Built-in variable discovery
+# ---------------------------------------------------------------------------
+
+
+def _discover_builtin_vars() -> frozenset[str]:
+    """Scan the execsql package source for ``$VARNAME`` system variables."""
+    import importlib.util
+
+    _rx_add_sub = re.compile(r'(?:(?<!\w)add_substitution|(?<!\w)sv)\s*\(\s*["\'](\$\w+)["\']')
+    _rx_lazy = re.compile(r'register_lazy\s*\(\s*["\'](\$\w+)["\']')
+
+    names: set[str] = set()
+
+    spec = importlib.util.find_spec("execsql")
+    if spec is None or spec.submodule_search_locations is None:
+        return frozenset(names)
+
+    pkg_dir = Path(spec.submodule_search_locations[0])
+    for src_file in pkg_dir.rglob("*.py"):
+        try:
+            text = src_file.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        for m in _rx_add_sub.finditer(text):
+            names.add(m.group(1).lstrip("$").upper())
+        for m in _rx_lazy.finditer(text):
+            names.add(m.group(1).lstrip("$").upper())
+
+    return frozenset(names)
+
+
+_BUILTIN_VARS: frozenset[str] | None = None
+
+
+def _get_builtin_vars() -> frozenset[str]:
+    """Return the cached set of built-in variable names, discovering on first call."""
+    global _BUILTIN_VARS
+    if _BUILTIN_VARS is None:
+        _BUILTIN_VARS = _discover_builtin_vars()
+    return _BUILTIN_VARS
+
+
+# ---------------------------------------------------------------------------
+# AST walker helpers
+# ---------------------------------------------------------------------------
+
+
+def _collect_script_blocks(script: Script) -> dict[str, ScriptBlock]:
+    """Build a name → ScriptBlock lookup from all ScriptBlock nodes in the tree."""
+    blocks: dict[str, ScriptBlock] = {}
+    for node in script.walk():
+        if isinstance(node, ScriptBlock):
+            blocks[node.name] = node
+    return blocks
+
+
+def _collect_defined_vars_from_nodes(
+    nodes: list[Node],
+    script_blocks: dict[str, ScriptBlock],
+    script_dir: Path | None,
+    defined: set[str],
+    visited: set[str] | None = None,
+) -> None:
+    """Walk nodes and collect variable definitions into *defined*."""
+    if visited is None:
+        visited = set()
+
+    for node in nodes:
+        if isinstance(node, MetaCommandStatement):
+            _extract_var_definition(node.command, script_dir, defined)
+
+        elif isinstance(node, IncludeDirective) and node.is_execute_script:
+            target = node.target.lower()
+            if target in script_blocks and target not in visited:
+                visited.add(target)
+                _collect_defined_vars_from_nodes(
+                    script_blocks[target].body,
+                    script_blocks,
+                    script_dir,
+                    defined,
+                    visited,
+                )
+
+        # Recurse into block children
+        if isinstance(node, (IfBlock, LoopBlock, BatchBlock, ScriptBlock, SqlBlock)):
+            _collect_defined_vars_from_nodes(
+                list(node.children()),
+                script_blocks,
+                script_dir,
+                defined,
+                visited,
+            )
+
+
+def _extract_var_definition(
+    command: str,
+    script_dir: Path | None,
+    defined: set[str],
+) -> None:
+    """Extract variable name from a SUB-family metacommand into *defined*."""
+    for rx in (
+        _RX_SUB,
+        _RX_SUB_EMPTY,
+        _RX_SUB_ADD,
+        _RX_SUB_APPEND,
+        _RX_SUBDATA,
+        _RX_SUB_LOCAL,
+        _RX_SUB_TEMPFILE,
+        _RX_SUB_DECRYPT,
+        _RX_SUB_ENCRYPT,
+        _RX_SUB_QUERYSTRING,
+    ):
+        m = rx.match(command)
+        if m:
+            defined.add(m.group("name").lstrip("+~").upper())
+            return
+
+    # SUB_INI bulk-defines from INI file — read keys at lint time
+    ini_m = _RX_SUB_INI.match(command)
+    if ini_m:
+        ini_file = ini_m.group("qfile") or ini_m.group("file")
+        ini_section = ini_m.group("section")
+        if ini_file and not _RX_VAR_REF.search(ini_file):
+            _read_ini_vars(ini_file, ini_section, script_dir, defined)
+
+
+def _read_ini_vars(
+    ini_file: str,
+    section: str,
+    script_dir: Path | None,
+    defined_vars: set[str],
+) -> None:
+    """Read an INI file and register its section keys as defined variables."""
+    from configparser import ConfigParser
+
+    p = Path(ini_file)
+    if not p.is_absolute() and script_dir is not None:
+        p = script_dir / p
+
+    if not p.exists():
+        return
+
+    cp = ConfigParser()
+    cp.read(p)
+    if cp.has_section(section):
+        for key, _value in cp.items(section):
+            defined_vars.add(key.upper())
+
+
+def _check_var_ref(
+    raw_name: str,
+    source: str,
+    line_no: int,
+    defined_vars: set[str],
+    issues: list[_Issue],
+) -> None:
+    """Emit a warning if *raw_name* looks like an undefined user variable."""
+    if not raw_name:
+        return
+
+    sigil = raw_name[0] if raw_name[0] in ("$", "@", "&", "~", "#", "+") else ""
+    name = raw_name[len(sigil) :]
+
+    # Skip non-$ sigil prefixes — resolved at runtime
+    if sigil in ("@", "&", "~", "#", "+"):
+        return
+
+    # $ARG_N is set via -a/--assign-arg at invocation time
+    if re.match(r"^ARG_\d+$", name, re.I):
+        return
+
+    # $COUNTER_N is managed by CounterVars
+    if re.match(r"^COUNTER_\d+$", name, re.I):
+        return
+
+    # Built-in system variables
+    if name.upper() in _get_builtin_vars():
+        return
+
+    # User-defined via SUB
+    if name.upper() in defined_vars:
+        return
+
+    issues.append(
+        _warning(
+            source,
+            line_no,
+            f"Potentially undefined variable: !!{raw_name}!! "
+            "(not defined by a preceding SUB; may be set by a config file or -a arg)",
+        ),
+    )
+
+
+def _check_include_path(
+    raw_path: str,
+    script_dir: Path | None,
+    source: str,
+    line_no: int,
+    issues: list[_Issue],
+) -> None:
+    """Warn if the INCLUDE target does not exist on disk."""
+    p = Path(raw_path)
+    if not p.is_absolute() and script_dir is not None:
+        p = script_dir / p
+
+    if not p.exists():
+        issues.append(
+            _warning(source, line_no, f"INCLUDE target does not exist: {raw_path!r}"),
+        )
+
+
+# ---------------------------------------------------------------------------
+# Core lint walk
+# ---------------------------------------------------------------------------
+
+
+def _lint_nodes(
+    nodes: list[Node],
+    script_dir: Path | None,
+    defined_vars: set[str],
+    script_blocks: dict[str, ScriptBlock],
+    issues: list[_Issue],
+    *,
+    visited_scripts: set[str] | None = None,
+) -> None:
+    """Walk a list of AST nodes and collect lint issues."""
+    if visited_scripts is None:
+        visited_scripts = set()
+
+    for node in nodes:
+        src = node.span.file
+        lno = node.span.start_line
+
+        # -- Variable references in SQL --
+        if isinstance(node, SqlStatement):
+            for m in _RX_VAR_REF.finditer(node.text):
+                _check_var_ref(m.group(1), src, lno, defined_vars, issues)
+
+        # -- Metacommand checks --
+        elif isinstance(node, MetaCommandStatement):
+            for m in _RX_VAR_REF.finditer(node.command):
+                _check_var_ref(m.group(1), src, lno, defined_vars, issues)
+
+        # -- IncludeDirective checks --
+        elif isinstance(node, IncludeDirective):
+            if node.is_execute_script:
+                target = node.target.lower()
+                if target not in script_blocks:
+                    if not node.if_exists:
+                        issues.append(
+                            _warning(src, lno, f"EXECUTE SCRIPT target not found: '{target}'"),
+                        )
+                elif target not in visited_scripts:
+                    visited_scripts.add(target)
+                    _lint_nodes(
+                        script_blocks[target].body,
+                        script_dir,
+                        defined_vars,
+                        script_blocks,
+                        issues,
+                        visited_scripts=visited_scripts,
+                    )
+            else:
+                # INCLUDE file existence check
+                if not node.if_exists:
+                    raw_path = node.target.strip().strip("\"'")
+                    if not _RX_VAR_REF.search(raw_path):
+                        _check_include_path(raw_path, script_dir, src, lno, issues)
+
+        # -- Recurse into block children --
+        if isinstance(node, IfBlock):
+            _lint_nodes(node.body, script_dir, defined_vars, script_blocks, issues, visited_scripts=visited_scripts)
+            for clause in node.elseif_clauses:
+                _lint_nodes(
+                    clause.body,
+                    script_dir,
+                    defined_vars,
+                    script_blocks,
+                    issues,
+                    visited_scripts=visited_scripts,
+                )
+            _lint_nodes(
+                node.else_body,
+                script_dir,
+                defined_vars,
+                script_blocks,
+                issues,
+                visited_scripts=visited_scripts,
+            )
+        elif isinstance(node, (LoopBlock, BatchBlock, SqlBlock)):
+            _lint_nodes(node.body, script_dir, defined_vars, script_blocks, issues, visited_scripts=visited_scripts)
+        elif isinstance(node, ScriptBlock):
+            # Lint script block body (structural errors already caught by parser)
+            if node.name not in visited_scripts:
+                visited_scripts.add(node.name)
+                sub_issues: list[_Issue] = []
+                _lint_nodes(
+                    node.body,
+                    script_dir,
+                    defined_vars,
+                    script_blocks,
+                    sub_issues,
+                    visited_scripts=visited_scripts,
+                )
+                for sev, ssrc, slno, msg in sub_issues:
+                    issues.append((sev, ssrc, slno, f"[script '{node.name}'] {msg}"))
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+
+def lint(
+    script: Script,
+    script_path: str | None = None,
+) -> list[_Issue]:
+    """Perform static analysis on an AST-parsed script.
+
+    Args:
+        script: The parsed :class:`Script` tree.
+        script_path: Path to the source file (for resolving relative
+            INCLUDE paths).  ``None`` for inline scripts.
+
+    Returns:
+        List of ``(severity, source, line_no, message)`` issue tuples.
+    """
+    issues: list[_Issue] = []
+
+    if not script.body:
+        issues.append(_warning("<script>", 0, "Script is empty — no commands found"))
+        return issues
+
+    script_dir = Path(script_path).resolve().parent if script_path else None
+    script_blocks = _collect_script_blocks(script)
+
+    # Pass 1: collect all variable definitions
+    all_defined: set[str] = set()
+    _collect_defined_vars_from_nodes(script.body, script_blocks, script_dir, all_defined)
+
+    # Pass 2: lint for variable and include issues
+    _lint_nodes(
+        script.body,
+        script_dir,
+        all_defined,
+        script_blocks,
+        issues,
+    )
+
+    return issues
+
+
+# ---------------------------------------------------------------------------
+# Result printing
+# ---------------------------------------------------------------------------
+
+
 def _print_lint_results(issues: list[_Issue], script_label: str) -> int:
     """Print lint issues to the console using Rich formatting.
 

execsql/metacommands/dispatch.py

@@ -1377,8 +1377,8 @@ def build_dispatch_table() -> MetaCommandList:
     # BEGIN / END BATCH / ROLLBACK
     # ------------------------------------------------------------------
     mcl.add(r"^\s*BEGIN\s+BATCH\s*$", x_begin_batch, description="BEGIN BATCH", category="block")
-    mcl.add(r"^\s*END\s+BATCH\s*$", x_end_batch, "END BATCH", run_in_batch=True, category="block")
-    mcl.add(r"^\s*ROLLBACK(:?\s+BATCH)?\s*$", x_rollback, "ROLLBACK BATCH", run_in_batch=True, category="block")
+    mcl.add(r"^\s*END\s+BATCH\s*$", x_end_batch, "END BATCH", category="block")
+    mcl.add(r"^\s*ROLLBACK(:?\s+BATCH)?\s*$", x_rollback, "ROLLBACK BATCH", category="block")
 
     # ------------------------------------------------------------------
     # ERROR_HALT / METACOMMAND_ERROR_HALT / CANCEL_HALT
@@ -1727,14 +1727,12 @@ def build_dispatch_table() -> MetaCommandList:
         x_assert,
         description="ASSERT",
         category="action",
-        run_when_false=False,
     )
     mcl.add(
         r"^\s*ASSERT\s+(?P<condtest>.+?)\s+(?P<message>(?:\"[^\"]*\"|'[^']*'))\s*$",
         x_assert,
         description="ASSERT",
         category="action",
-        run_when_false=False,
     )
 
     # ------------------------------------------------------------------
@@ -1745,7 +1743,6 @@ def build_dispatch_table() -> MetaCommandList:
         x_breakpoint,
         description="BREAKPOINT",
         category="action",
-        run_when_false=False,
     )
 
     # ------------------------------------------------------------------
@@ -1765,26 +1762,24 @@ def build_dispatch_table() -> MetaCommandList:
         r"^\s*ORIF\s*\(\s*(?P<condtest>.+)\s*\)\s*$",
         x_if_orif,
         description="ORIF",
-        run_when_false=True,
         category="control",
     )
     mcl.add(
         r"^\s*ELSEIF\s*\(\s*(?P<condtest>.+)\s*\)\s*$",
         x_if_elseif,
         description="ELSEIF",
-        run_when_false=True,
         category="control",
     )
     mcl.add(r"^\s*ANDIF\s*\(\s*(?P<condtest>.+)\s*\)\s*$", x_if_andif, description="ANDIF", category="control")
-    mcl.add(r"^\s*ELSE\s*$", x_if_else, description="ELSE", run_when_false=True, category="control")
+    mcl.add(r"^\s*ELSE\s*$", x_if_else, description="ELSE", category="control")
     mcl.add(
         r"^\s*IF\s*\(\s*(?P<condtest>.+)\s*\)\s*{\s*(?P<condcmd>.+)\s*}\s*$",
         x_if,
         description="IF",
         category="control",
     )
-    mcl.add(r"^\s*IF\s*\(\s*(?P<condtest>.+)\s*\)\s*$", x_if_block, run_when_false=True, category="control")
-    mcl.add(r"^\s*ENDIF\s*$", x_if_end, description="ENDIF", run_when_false=True, category="control")
+    mcl.add(r"^\s*IF\s*\(\s*(?P<condtest>.+)\s*\)\s*$", x_if_block, category="control")
+    mcl.add(r"^\s*ENDIF\s*$", x_if_end, description="ENDIF", category="control")
 
     # ------------------------------------------------------------------
     # CONNECT — SQL Server

execsql/metacommands/script_ext.py

@@ -3,22 +3,23 @@ from __future__ import annotations
 """
 Script-block extension and dispatch handlers for execsql.
 
-Handlers for the named-script invocation and dynamic-extension
-metacommands. Used by both the AST executor and legacy command paths:
+Handlers for the named-script extension metacommands invoked by the
+AST executor:
 
-- ``x_executescript`` — ``EXECUTE SCRIPT <name>`` / ``RUN SCRIPT <name>``
-  (look up a previously-registered ``BEGIN SCRIPT`` block and run it,
-  optionally with parameter bindings and a WHILE / UNTIL loop).
 - ``x_extendscript`` — ``EXTEND SCRIPT <name> WITH SCRIPT|FILE …``
   (append additional commands to an existing named script block from
   an inline source).
 - ``x_extendscript_metacommand`` — ``EXTEND SCRIPT … WITH METACOMMAND …``.
 - ``x_extendscript_sql`` — ``EXTEND SCRIPT … WITH SQL …``.
+- ``x_executescript`` — dispatch-table sentinel only. ``EXECUTE SCRIPT``
+  / ``RUN SCRIPT`` are handled natively by the AST executor; this stub
+  raises ``ErrInfo`` if the parser ever fails to recognize them as
+  structural nodes.
 
 Registration of ``BEGIN SCRIPT … END SCRIPT`` blocks themselves is
 handled by the AST parser (block boundaries) and executor (registering
-the block on ``ctx.ast_scripts``); this module is only the call-site /
-extension handlers.
+the block on ``ctx.ast_scripts``); this module is only the
+extension-site handlers.
 """
 
 import copy

execsql/script/engine.py

@@ -67,25 +67,18 @@ class MetaCommand:
         rx: Any,
         exec_func: Any,
         description: str | None = None,
-        run_in_batch: bool = False,
-        run_when_false: bool = False,
         set_error_flag: bool = True,
         category: str | None = None,
     ) -> None:
         self.rx = rx
         self.exec_fn = exec_func
         self.description = description
-        self.run_in_batch = run_in_batch
-        self.run_when_false = run_when_false
         self.set_error_flag = set_error_flag
         self.category = category
         self.hitcount = 0
 
     def __repr__(self) -> str:
-        return (
-            f"MetaCommand({self.rx.pattern!r}, {self.exec_fn!r}, {self.description!r}, "
-            f"{self.run_in_batch!r}, {self.run_when_false!r})"
-        )
+        return f"MetaCommand({self.rx.pattern!r}, {self.exec_fn!r}, {self.description!r})"
 
     def run(self, cmd_str: str) -> tuple:
         """Match *cmd_str* against this entry's regex and, if it matches, invoke the handler.
@@ -171,8 +164,6 @@ class MetaCommandList:
         matching_regexes: Any,
         exec_func: Any,
         description: str | None = None,
-        run_in_batch: bool = False,
-        run_when_false: bool = False,
         set_error_flag: bool = True,
         category: str | None = None,
     ) -> None:
@@ -193,8 +184,6 @@ class MetaCommandList:
                 rx,
                 exec_func,
                 description,
-                run_in_batch,
-                run_when_false,
                 set_error_flag,
                 category,
             )