maxc-cli 0.3.2__tar.gz → 0.3.3__tar.gz

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.3.2
+Version: 0.3.3
 Summary: Agent-native MaxCompute CLI for external coding agents
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/setup.py

@@ -9,7 +9,7 @@ README = ROOT / "README.md"
 
 setup(
     name="maxc-cli",
-    version="0.3.2",
+    version="0.3.3",
     description="Agent-native MaxCompute CLI for external coding agents",
     long_description=README.read_text(encoding="utf-8"),
     long_description_content_type="text/markdown",

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/src/maxc_cli/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.3.2"
+__version__ = "0.3.3"

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/src/maxc_cli/app.py

@@ -2161,7 +2161,13 @@ class MaxCApp:
         self.log("meta.list-schemas", envelope.status, envelope.metadata)
         return envelope
 
-    def session_set(self, project: 'str | None' = None, schema: 'str | None' = None) -> 'Envelope':
+    def session_set(
+        self,
+        project: 'str | None' = None,
+        schema: 'str | None' = None,
+        *,
+        target_config_path: 'Path | None' = None,
+    ) -> 'Envelope':
         """Set default project and/or schema by writing to ~/.maxc/config.yaml.
 
         Mirrors `gcloud config set project` / `kubectl config use-context`: the
@@ -2169,8 +2175,12 @@ class MaxCApp:
         (e.g., ./.maxc/config.yaml) shadows the value, a warning is emitted but
         the write still happens — the in-memory value is updated for the current
         invocation.
+
+        When ``target_config_path`` is given (i.e. the user passed ``--config``),
+        the write goes to that file instead, so a subsequent ``session show
+        --config <same>`` round-trips correctly.
         """
-        target_path = default_global_config_path()
+        target_path = target_config_path or default_global_config_path()
         config_payload = load_config_mapping(target_path) if target_path.exists() else {}
 
         changes: list[str] = []
@@ -2246,13 +2256,18 @@ class MaxCApp:
         self.log("session.set", envelope.status, {"changes": changes})
         return envelope
     
-    def session_unset(self) -> 'Envelope':
+    def session_unset(
+        self, *, target_config_path: 'Path | None' = None
+    ) -> 'Envelope':
         """Remove default_project / default_schema from ~/.maxc/config.yaml.
 
         Project-level config files in the working directory are NOT modified, since
         they may be checked into version control. Edit those by hand if needed.
+
+        When ``target_config_path`` is given (``--config``), unset operates on
+        that file instead of the global one.
         """
-        target_path = default_global_config_path()
+        target_path = target_config_path or default_global_config_path()
         cleared: list[str] = []
 
         if target_path.exists():
@@ -2284,9 +2299,16 @@ class MaxCApp:
         self.log("session.unset", envelope.status, {})
         return envelope
     
-    def session_show(self) -> 'Envelope':
-        """Show current session settings with source information."""
-        config_path = default_global_config_path()
+    def session_show(
+        self, *, target_config_path: 'Path | None' = None
+    ) -> 'Envelope':
+        """Show current session settings with source information.
+
+        When ``target_config_path`` is given (``--config``), the reported
+        ``config_path`` reflects that file, matching what ``session set
+        --config <same>`` would write to.
+        """
+        config_path = target_config_path or default_global_config_path()
 
         env_project = os.environ.get("MAXCOMPUTE_PROJECT") or os.environ.get("ODPS_PROJECT")
         has_explicit_auth_provider = bool(self.config.auth.provider)

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/src/maxc_cli/backend/query.py

@@ -356,13 +356,14 @@ class QueryMixin:
 
         actual_sql, hints, priority = _parse_sql_with_hints(sql, force=force)
         priority_kwargs = {"priority": priority} if priority is not None else {}
+        idem_kwargs = {"unique_identifier_id": idempotency_key} if idempotency_key is not None else {}
 
         try:
             instance = self.client.run_sql(
                 actual_sql,
                 project=project,
                 hints=hints,
-                unique_identifier_id=idempotency_key,
+                **idem_kwargs,
                 **priority_kwargs,
             )
         except Exception as exc:

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/src/maxc_cli/cli.py

@@ -82,6 +82,10 @@ def _epilog_for(command_path: str) -> str | None:
 # (e.g., --project, --limit) are NOT hoisted — they belong to specific
 # subparsers. arity = number of subsequent argv tokens consumed as a value
 # when given as `--flag value`; `--flag=value` is always a single token.
+#
+# -h/--help is deliberately NOT hoisted: argparse auto-adds it to every
+# subparser, and hoisting would turn `maxc query -h` into top-level help
+# instead of the query subcommand's help.
 _GLOBAL_FLAG_ARITY: dict[str, int] = {
     "--format":  1,
     "-f":        1,
@@ -92,8 +96,6 @@ _GLOBAL_FLAG_ARITY: dict[str, int] = {
     "--debug":   0,
     "-v":        0,
     "--version": 0,
-    "--help":    0,
-    "-h":        0,
 }
 
 
@@ -1297,23 +1299,27 @@ def _handle_session_set(app: MaxCApp, args: argparse.Namespace, stdout: TextIO)
     """Set current project and/or schema for the session."""
     project = args.project
     schema = args.schema
-    
+
     if not project and not schema:
         raise ValidationError("At least one of `--project` or `--schema` must be specified.")
-    
-    envelope = app.session_set(project=project, schema=schema)
+
+    envelope = app.session_set(
+        project=project,
+        schema=schema,
+        target_config_path=args.requested_config_path,
+    )
     _emit_envelope(envelope, args=args, stdout=stdout, default_format="json")
 
 
 def _handle_session_show(app: MaxCApp, args: argparse.Namespace, stdout: TextIO) -> None:
     """Show current session settings."""
-    envelope = app.session_show()
+    envelope = app.session_show(target_config_path=args.requested_config_path)
     _emit_envelope(envelope, args=args, stdout=stdout, default_format="json")
 
 
 def _handle_session_unset(app: MaxCApp, args: argparse.Namespace, stdout: TextIO) -> None:
     """Clear session override."""
-    envelope = app.session_unset()
+    envelope = app.session_unset(target_config_path=args.requested_config_path)
     _emit_envelope(envelope, args=args, stdout=stdout, default_format="json")
 
 

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/src/maxc_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.3.2
+Version: 0.3.3
 Summary: Agent-native MaxCompute CLI for external coding agents
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/src/maxc_cli.egg-info/SOURCES.txt

@@ -76,6 +76,7 @@ tests/test_exit_codes.py
 tests/test_external_auth.py
 tests/test_flag_hoist.py
 tests/test_help_format.py
+tests/test_help_version_e2e.py
 tests/test_helpers.py
 tests/test_helpers_csv.py
 tests/test_integration.py

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/tests/test_cli_mock.py

@@ -1007,11 +1007,36 @@ def test_legacy_session_override_is_migrated_into_global_config(
 
 
 def test_session_set_writes_to_global_config(tmp_path: 'Path', monkeypatch) -> None:
-    """session set should persist project/schema to ~/.maxc/config.yaml, no override file created."""
+    """When --config is NOT passed, session set persists to ~/.maxc/config.yaml."""
     clear_odps_env(monkeypatch)
     isolate_home(monkeypatch, tmp_path)
 
-    config_path = tmp_path / "config.yaml"
+    # No --config: rely on normal discovery so session set hits the global path.
+    code, payload, _ = run_json_command(
+        tmp_path, None,
+        ["session", "set", "--project", "new_proj", "--schema", "new_schema", "--json"],
+    )
+    assert code == 0
+    assert payload["status"] == "success"
+    assert payload["data"]["project"] == "new_proj"
+    assert payload["data"]["schema"] == "new_schema"
+
+    global_config_path = tmp_path / ".maxc" / "config.yaml"
+    assert global_config_path.exists()
+    persisted = yaml.safe_load(global_config_path.read_text(encoding="utf-8"))
+    assert persisted["default_project"] == "new_proj"
+    assert persisted["default_schema"] == "new_schema"
+
+    assert not (tmp_path / ".maxc" / "session_override.yaml").exists()
+
+
+def test_session_set_writes_to_explicit_config_when_passed(tmp_path: 'Path', monkeypatch) -> None:
+    """When --config is passed, session set writes to THAT file (not global), so
+    a subsequent `session show --config <same>` round-trips."""
+    clear_odps_env(monkeypatch)
+    isolate_home(monkeypatch, tmp_path)
+
+    config_path = tmp_path / "explicit.yaml"
     config_path.write_text(
         "default_project: demo\n"
         "default_format: json\n"
@@ -1026,16 +1051,20 @@ def test_session_set_writes_to_global_config(tmp_path: 'Path', monkeypatch) -> N
     )
     assert code == 0
     assert payload["status"] == "success"
-    assert payload["data"]["project"] == "new_proj"
-    assert payload["data"]["schema"] == "new_schema"
 
-    global_config_path = tmp_path / ".maxc" / "config.yaml"
-    assert global_config_path.exists()
-    persisted = yaml.safe_load(global_config_path.read_text(encoding="utf-8"))
+    persisted = yaml.safe_load(config_path.read_text(encoding="utf-8"))
     assert persisted["default_project"] == "new_proj"
     assert persisted["default_schema"] == "new_schema"
+    # Global file must NOT be touched when --config is explicit.
+    assert not (tmp_path / ".maxc" / "config.yaml").exists()
 
-    assert not (tmp_path / ".maxc" / "session_override.yaml").exists()
+    # Round-trip: session show via same --config sees the new value.
+    code, show_payload, _ = run_json_command(
+        tmp_path, config_path, ["session", "show", "--json"]
+    )
+    assert code == 0
+    assert show_payload["data"]["project"]["value"] == "new_proj"
+    assert show_payload["data"]["schema"]["value"] == "new_schema"
 
 
 def test_session_set_warns_when_project_config_shadows(tmp_path: 'Path', monkeypatch) -> None:

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/tests/test_e2e_smoke.py

@@ -85,11 +85,11 @@ def test_e2e_bootstrap_session_query(tmp_path: Path, monkeypatch) -> None:
     assert code == 0, f"session show failed: {payload}"
     project_info = payload["data"]["project"]
     schema_info = payload["data"]["schema"]
-    # session show may return {"source": ..., "value": ...} dicts or plain strings
-    project_val = project_info["value"] if isinstance(project_info, dict) else project_info
-    schema_val = schema_info["value"] if isinstance(schema_info, dict) else schema_info
-    assert project_val == "other_project"
-    assert schema_val == "my_schema"
+    # session show always returns {"value": ..., "source": ...} dicts; assert
+    # the shape directly so a future flattening regression fails this test.
+    assert isinstance(project_info, dict) and isinstance(schema_info, dict), payload
+    assert project_info["value"] == "other_project"
+    assert schema_info["value"] == "my_schema"
 
     # 5. session unset — revert
     code, payload, _ = run_cmd(tmp_path, config_path, ["session", "unset", "--json"])
@@ -99,8 +99,8 @@ def test_e2e_bootstrap_session_query(tmp_path: Path, monkeypatch) -> None:
     code, payload, _ = run_cmd(tmp_path, config_path, ["session", "show", "--json"])
     assert code == 0
     project_info = payload["data"]["project"]
-    project_val = project_info["value"] if isinstance(project_info, dict) else project_info
-    assert project_val == "smoke_project"
+    assert isinstance(project_info, dict), payload
+    assert project_info["value"] == "smoke_project"
 
     # 7. agent context — quick config summary
     code, payload, _ = run_cmd(tmp_path, config_path, ["agent", "context", "--json"])

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/tests/test_flag_hoist.py

@@ -33,9 +33,14 @@ from maxc_cli.cli import _hoist_global_flags
         (["meta", "describe", "t", "--json", "--quiet"], ["--json", "--quiet", "meta", "describe", "t"]),
         # No arguments
         ([], []),
-        # Help / version flags
-        (["query", "x", "--help"], ["--help", "query", "x"]),
+        # --version is hoisted (only the top-level parser defines it)
         (["--version"], ["--version"]),
+        (["query", "x", "-v"], ["-v", "query", "x"]),
+        # -h/--help is NOT hoisted — every subparser auto-registers its own,
+        # so `maxc query -h` must reach the query subparser, not the root.
+        (["query", "x", "--help"], ["query", "x", "--help"]),
+        (["query", "x", "-h"], ["query", "x", "-h"]),
+        (["agent", "skill", "install", "-h"], ["agent", "skill", "install", "-h"]),
     ],
 )
 def test_hoist_matrix(raw, expected):

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/tests/test_help_format.py

@@ -130,14 +130,14 @@ def test_multi_line_description_preserved():
         description="line one\nline two\nline three",
     )
     text = strip_ansi(p.format_help())
-    assert "line one" in text
-    assert "line two" in text
-    assert "line three" in text
-    # All three appear on separate lines.
-    desc_block = text.split("Usage:")[0]  # description renders before Usage
-    assert "line one" in desc_block.split("\n")[0:8] or any(
-        ln.strip() == "line one" for ln in text.splitlines()
-    )
+    # Each of the three input lines must appear as its OWN stripped line —
+    # not collapsed onto a shared line. (AliyunStyleFormatter renders the
+    # description block between "Usage:" and "Flags:".)
+    stripped_lines = [ln.strip() for ln in text.splitlines()]
+    for expected in ("line one", "line two", "line three"):
+        assert expected in stripped_lines, (
+            f"{expected!r} not on its own line in:\n{text}"
+        )
 
 
 def test_top_level_maxc_help_uses_aliyun_style(monkeypatch):

maxc_cli-0.3.3/tests/test_help_version_e2e.py

@@ -0,0 +1,144 @@
+"""Black-box guard: argparse-eager flags reach the parser the user typed at.
+
+Spawned as actual subprocesses (`python -m maxc_cli ...`) so these tests
+also catch regressions that in-process tests miss: broken console_scripts
+entry, import errors at startup, module-level side effects.
+
+The motivating regression: a `_hoist_global_flags` change pushed `-h` to the
+front of argv, which made `maxc query -h` print the TOP-LEVEL help instead
+of the `query` subparser's help. The bug shipped because the only test was
+a unit test that asserted the wrong post-hoist argv shape.
+"""
+from __future__ import annotations
+
+import subprocess
+import sys
+
+import pytest
+
+from maxc_cli import __version__
+
+pytestmark = pytest.mark.e2e
+
+
+def _maxc_argv() -> list[str]:
+    # `python -m maxc_cli` avoids depending on PATH resolution of the
+    # `maxc` console script, so the test works in any environment where
+    # maxc_cli is importable (which is already a prerequisite for the
+    # rest of the test suite).
+    return [sys.executable, "-m", "maxc_cli"]
+
+
+def _run(argv: list[str], timeout: float = 15.0) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [*_maxc_argv(), *argv],
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+
+
+# Each row: (argv, must_appear_in_stdout, must_NOT_appear_in_stdout).
+# `must_not` is the critical half — it catches the case where every help
+# request silently degrades to top-level help.
+_TOPLEVEL_COMMAND_LIST = "{query,job,meta,session,data,auth,agent,cache}"
+
+
+@pytest.mark.parametrize(
+    "argv, must_contain, must_not_contain",
+    [
+        # Top-level help (sanity — must show the command list).
+        (["-h"],     [_TOPLEVEL_COMMAND_LIST], []),
+        (["--help"], [_TOPLEVEL_COMMAND_LIST], []),
+        # 1-deep subparser help: must show the subcommand's own usage line,
+        # must NOT degrade to the top-level command list.
+        (["query", "-h"],     ["maxc query"], [_TOPLEVEL_COMMAND_LIST]),
+        (["query", "--help"], ["maxc query"], [_TOPLEVEL_COMMAND_LIST]),
+        # 2-deep nested (agent subcommands).
+        (["agent", "skill", "-h"],
+         ["maxc agent skill", "{install,update,uninstall,list,diff,path}"],
+         [_TOPLEVEL_COMMAND_LIST]),
+        # 3-deep nested (agent skill install — the worst-case hoist regression).
+        (["agent", "skill", "install", "-h"],
+         ["maxc agent skill install", "{claude-code,cursor"],
+         [_TOPLEVEL_COMMAND_LIST]),
+        # Leaf with distinctive flags — proves it's really the leaf's help.
+        (["auth", "login", "--help"],
+         ["maxc auth login", "--access-id"],
+         [_TOPLEVEL_COMMAND_LIST]),
+        (["meta", "describe", "-h"],
+         ["maxc meta describe", "--schema"],
+         [_TOPLEVEL_COMMAND_LIST]),
+        # Other hoistable globals MUST NOT redirect --help. If --debug is
+        # hoisted to the front, --help must still reach the query subparser.
+        (["--debug", "query", "--help"],
+         ["maxc query"],
+         [_TOPLEVEL_COMMAND_LIST]),
+        # --help after a positional value (post-SQL) must still reach the
+        # subparser — regression check for any future "hoist --help after
+        # positional" attempt.
+        (["query", "SELECT 1", "-h"],
+         ["maxc query"],
+         [_TOPLEVEL_COMMAND_LIST]),
+    ],
+    ids=[
+        "top -h",
+        "top --help",
+        "query -h",
+        "query --help",
+        "agent skill -h (nested)",
+        "agent skill install -h (deep nested)",
+        "auth login --help (leaf with --access-id)",
+        "meta describe -h (leaf with --schema)",
+        "--debug query --help (hoist coexists)",
+        "query SQL -h (help after positional)",
+    ],
+)
+def test_help_reaches_correct_parser(
+    argv: list[str],
+    must_contain: list[str],
+    must_not_contain: list[str],
+) -> None:
+    result = _run(argv)
+    assert result.returncode == 0, (
+        f"argv={argv!r} exited {result.returncode}\nstderr:\n{result.stderr}"
+    )
+    out = result.stdout
+    for needle in must_contain:
+        assert needle in out, (
+            f"argv={argv!r}: expected {needle!r} in help output, got:\n{out}"
+        )
+    for needle in must_not_contain:
+        assert needle not in out, (
+            f"argv={argv!r}: help silently degraded — found top-level marker "
+            f"{needle!r} in:\n{out}"
+        )
+
+
+@pytest.mark.parametrize(
+    "argv",
+    [
+        ["-v"],
+        ["--version"],
+        # --version is hoisted on purpose (only the top parser defines it).
+        # These prove the hoist for version still works after the -h/--help
+        # hoist was removed.
+        ["query", "-v"],
+        ["query", "--version"],
+        ["agent", "skill", "install", "--version"],
+    ],
+    ids=["top -v", "top --version", "query -v (hoisted)",
+         "query --version (hoisted)", "deep --version (hoisted)"],
+)
+def test_version_reaches_top_parser(argv: list[str]) -> None:
+    result = _run(argv)
+    assert result.returncode == 0, (
+        f"argv={argv!r} exited {result.returncode}\nstderr:\n{result.stderr}"
+    )
+    # argparse writes --version output to stdout in Python 3.4+.
+    out = (result.stdout or "") + (result.stderr or "")
+    expected = f"maxc {__version__}"
+    assert expected in out, (
+        f"argv={argv!r}: expected {expected!r}, got stdout={result.stdout!r} "
+        f"stderr={result.stderr!r}"
+    )

{maxc_cli-0.3.2 → maxc_cli-0.3.3}/tests/test_phase1_improvements.py

@@ -640,11 +640,9 @@ class TestInstallSkillExclusion:
     """B3 — skill_install skips .git/ and similar junk."""
 
     def test_excluded_names_are_skipped(self, tmp_path, monkeypatch):
-        from pathlib import Path
-
         from maxc_cli.app import MaxCApp
 
-        # Build a fake skills dir
+        # Build a fake skills source with both real content and junk to be excluded.
         fake_skills = tmp_path / "fake_skills"
         fake_skills.mkdir()
         (fake_skills / "SKILL.md").write_text("# skill")
@@ -654,66 +652,46 @@ class TestInstallSkillExclusion:
         (fake_skills / "stale.pyc").write_text("junk")
         (fake_skills / "references").mkdir()
         (fake_skills / "references" / "doc.md").write_text("real doc")
+        (fake_skills / "references" / "__pycache__").mkdir()
+        (fake_skills / "references" / "__pycache__" / "x.cpython-312.pyc").write_text("junk")
 
-        # Monkeypatch importlib.resources.files to return our fake dir
-        class _Files:
-            def __init__(self, p):
-                self._p = Path(p)
-            def __truediv__(self, other):
-                return _Files(self._p / other)
-            def is_dir(self):
-                return self._p.is_dir()
-            def is_file(self):
-                return self._p.is_file()
-            def __str__(self):
-                return str(self._p)
-            def iterdir(self):
-                return self._p.iterdir()
-
-        def fake_files(pkg):
-            return _Files(fake_skills.parent)
-
-        # Set up minimal config so MaxCApp loads
         config_path = tmp_path / "config.yaml"
         config_path.write_text(
             "auth:\n  provider: access_key\n  access_id: x\n  secret_access_key: y\n"
             "default_project: p\nbackend:\n  type: odps\n"
         )
-        MaxCApp(cwd=tmp_path, config_path=config_path, load_backend=False)
+        app = MaxCApp(cwd=tmp_path, config_path=config_path, load_backend=False)
+
+        # Route production _locate_skills_source at the fake tree so we exercise
+        # the real _render_skill_into exclusion logic end-to-end.
+        monkeypatch.setattr(app, "_locate_skills_source", lambda: fake_skills)
 
-        # Install dir
         install_root = tmp_path / "install"
-        # Bypass the platform map by directly testing the iteration logic
-        import shutil
-        EXCLUDED_NAMES = {".git", "__pycache__", ".DS_Store", "nohup.out", ".gitignore", ".pytest_cache", ".mypy_cache", ".ruff_cache"}
-        EXCLUDED_SUFFIXES = (".pyc", ".pyo", ".log")
-
-        def _is_excluded(name):
-            return name in EXCLUDED_NAMES or any(name.endswith(s) for s in EXCLUDED_SUFFIXES)
-
-        copied = []
-        install_root.mkdir()
-        for item in fake_skills.iterdir():
-            if _is_excluded(item.name):
-                continue
-            if item.is_file():
-                shutil.copy2(str(item), install_root / item.name)
-                copied.append(item.name)
-            elif item.is_dir():
-                shutil.copytree(
-                    str(item),
-                    str(install_root / item.name),
-                    ignore=shutil.ignore_patterns(*EXCLUDED_NAMES, "*.pyc"),
-                )
-                copied.append(item.name + "/")
+        # `cursor` has no extra_files → no render_fn dependencies, keeps this
+        # test focused on the exclusion behavior under audit.
+        envelope = app.skill_install(
+            platform="cursor",
+            dir_override=install_root,
+        )
 
+        assert envelope.status == "success", envelope.error
+
+        # Real assertions: the installed tree must reflect production exclusion logic.
+        assert (install_root / "SKILL.md").exists()
+        assert (install_root / "references" / "doc.md").exists()
+        assert not (install_root / ".git").exists()
+        assert not (install_root / "nohup.out").exists()
+        assert not (install_root / "stale.pyc").exists()
+        assert not (install_root / "references" / "__pycache__").exists()
+
+        # And the envelope's files_copied list must agree.
+        copied = envelope.data["files_copied"]
         assert "SKILL.md" in copied
+        assert "references/" in copied
         assert ".git" not in copied
         assert ".git/" not in copied
         assert "nohup.out" not in copied
         assert "stale.pyc" not in copied
-        assert "references/" in copied
-        assert (install_root / "references" / "doc.md").exists()
 
 
 class TestRenderBriefPreview: