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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxc-cli
-Version: 0.3.1
+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.1 → maxc_cli-0.3.3}/setup.py

@@ -9,7 +9,7 @@ README = ROOT / "README.md"
 
 setup(
     name="maxc-cli",
-    version="0.3.1",
+    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.1 → maxc_cli-0.3.3}/src/maxc_cli/__init__.py

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

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

@@ -21,6 +21,7 @@ from .backend import OdpsBackend
 from .cache import LocalCache
 from .config import (
     AuthConfig,
+    ExternalAuthConfig,
     TableDefinition,
     default_global_config_path,
     load_config,
@@ -2160,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
@@ -2168,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] = []
@@ -2245,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():
@@ -2283,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)
@@ -2740,7 +2763,6 @@ class MaxCApp:
         JSON to stdout.  See :class:`ExternalCredentialProvider` for the
         expected JSON format.
         """
-        from .auth_providers import ExternalAuthConfig
         target_path = target_config_path or default_global_config_path()
         existing_payload = load_config_mapping(target_path) if target_path.exists() else {}
         existing_auth = AuthConfig.from_mapping(existing_payload.get("auth", {}) or {})

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

@@ -46,15 +46,20 @@ def _count_statements(sql: 'str') -> 'int':
     return sum(1 for part in cleaned.split(";") if part.strip())
 
 
-def _parse_sql_with_hints(sql: 'str', *, force: 'bool' = False) -> 'tuple[str, dict[str, str]]':
+def _parse_sql_with_hints(
+    sql: 'str', *, force: 'bool' = False,
+) -> 'tuple[str, dict[str, str], int | None]':
     """Extract SET statements from *sql* and enforce client-side read-only mode.
 
-    Returns ``(remaining_sql, merged_hints)`` where ``merged_hints``
-    contains only user-supplied SET values.  Write operations
-    (INSERT, CREATE, DROP, etc.) are blocked unless *force* is ``True``.
+    Returns ``(remaining_sql, merged_hints, priority)``. ``merged_hints``
+    contains user-supplied SET values minus ``odps.instance.priority``,
+    which is lifted out into ``priority`` so callers can pass it as the
+    ``priority=`` kwarg of ``run_sql`` / ``execute_sql``.
 
-    Empty SQL raises ``ValidationError``. Multi-statement SQL automatically
-    receives ``odps.sql.submit.mode=script`` unless the user already set it.
+    Write operations (INSERT, CREATE, DROP, etc.) are blocked unless
+    *force* is ``True``. Empty SQL raises ``ValidationError``.
+    Multi-statement SQL automatically receives
+    ``odps.sql.submit.mode=script`` unless the user already set it.
     """
     parsed = SettingParser.parse(sql)
     if parsed.errors:
@@ -87,7 +92,34 @@ def _parse_sql_with_hints(sql: 'str', *, force: 'bool' = False) -> 'tuple[str, d
     if _count_statements(remaining) >= 2:
         hints.setdefault("odps.sql.submit.mode", "script")
 
-    return remaining, hints
+    # odps.instance.priority is not a SQL hint — it's a top-level kwarg on
+    # run_sql/execute_sql. Lift it out so the caller can thread it through.
+    priority = _pop_priority(hints)
+
+    return remaining, hints, priority
+
+
+def _pop_priority(hints: 'dict[str, str]') -> 'int | None':
+    """Pop ``odps.instance.priority`` from *hints* and parse as int.
+
+    Match is case-insensitive on the key. Returns ``None`` if absent.
+    Raises ``ValidationError`` if the value isn't an integer.
+    """
+    matched_key: str | None = None
+    for k in hints:
+        if k.lower() == "odps.instance.priority":
+            matched_key = k
+            break
+    if matched_key is None:
+        return None
+    raw = hints.pop(matched_key)
+    try:
+        return int(raw)
+    except (TypeError, ValueError):
+        raise ValidationError(
+            f"Invalid odps.instance.priority value {raw!r}: must be an integer.",
+            suggestion="Use SET odps.instance.priority=N; where N is an integer.",
+        ) from None
 
 
 class QueryMixin:
@@ -125,7 +157,8 @@ class QueryMixin:
             ValidationError: If SET syntax is invalid.
             BackendConnectionError: If ODPS connection fails.
         """
-        actual_sql, hints = _parse_sql_with_hints(sql, force=force)
+        actual_sql, hints, priority = _parse_sql_with_hints(sql, force=force)
+        priority_kwargs = {"priority": priority} if priority is not None else {}
 
         started_at = now_utc_iso()
         started_monotonic = monotonic()
@@ -162,7 +195,7 @@ class QueryMixin:
 
         try:
             instance = self.client.run_sql(
-                actual_sql, project=project, hints=hints,
+                actual_sql, project=project, hints=hints, **priority_kwargs,
             )
         except Exception as exc:
             raise translate_odps_error(exc) from exc
@@ -204,7 +237,7 @@ class QueryMixin:
         Returns:
             Dict with estimated_input_size_bytes, sql_complexity, sql_udf_num, etc.
         """
-        actual_sql, hints = _parse_sql_with_hints(sql, force=force)
+        actual_sql, hints, _priority = _parse_sql_with_hints(sql, force=force)
         started_monotonic = monotonic()
         try:
             sql_cost = self.client.execute_sql_cost(
@@ -240,7 +273,8 @@ class QueryMixin:
         Returns:
             Dict with query outline, cost metadata, and ``execution_plan`` text.
         """
-        actual_sql, hints = _parse_sql_with_hints(sql, force=force)
+        actual_sql, hints, priority = _parse_sql_with_hints(sql, force=force)
+        priority_kwargs = {"priority": priority} if priority is not None else {}
         # script-mode auto-hint doesn't apply to EXPLAIN itself; remove if present.
         explain_hints = {k: v for k, v in hints.items() if k != "odps.sql.submit.mode"}
         started_monotonic = monotonic()
@@ -252,6 +286,7 @@ class QueryMixin:
                 f"EXPLAIN {actual_sql}",
                 project=project,
                 hints=explain_hints,
+                **priority_kwargs,
             )
             try:
                 results = instance.get_task_results()
@@ -319,14 +354,17 @@ class QueryMixin:
         """
         from ..models import JobInfo
 
-        actual_sql, hints = _parse_sql_with_hints(sql, force=force)
+        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:
             raise translate_odps_error(exc) from exc

{maxc_cli-0.3.1 → 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.1 → 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.1
+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.1 → 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.1 → 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.1 → 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.1 → maxc_cli-0.3.3}/tests/test_external_auth.py

@@ -790,3 +790,57 @@ class TestAuthSeemsConfiguredExternal:
         self._clear_odps_env(monkeypatch)
         config = _minimal_config()
         assert _auth_seems_configured(self._stub_app(config)) is False
+
+
+# ============================================================
+# MaxCApp.auth_login_external — end-to-end regression
+# ============================================================
+
+class TestAuthLoginExternalAppMethod:
+    """Regression: a stale lazy import (``from .auth_providers import
+    ExternalAuthConfig``) in ``MaxCApp.auth_login_external`` raised
+    ``ImportError`` at runtime after a ruff F401 sweep removed the
+    transitive re-export from ``auth_providers``. The dataclass lives in
+    ``config``; the import must come from there. This test exercises the
+    method end-to-end so any future re-routing of ``ExternalAuthConfig``
+    that breaks the call site is caught immediately.
+    """
+
+    @staticmethod
+    def _clear_odps_env(monkeypatch):
+        import maxc_cli.backend as backend_module
+        for aliases in backend_module.ODPS_ENV_ALIASES.values():
+            for alias in aliases:
+                monkeypatch.delenv(alias, raising=False)
+
+    def test_writes_external_provider_config_without_validation(self, tmp_path, monkeypatch):
+        import yaml
+
+        from maxc_cli.app import MaxCApp
+        self._clear_odps_env(monkeypatch)
+        monkeypatch.chdir(tmp_path)
+        monkeypatch.setenv("HOME", str(tmp_path))
+
+        config_path = tmp_path / "config.yaml"
+        app = MaxCApp(cwd=tmp_path, load_backend=False)
+
+        envelope = app.auth_login_external(
+            process_command="/usr/bin/echo '{}'",
+            process_timeout=30,
+            project="proj_x",
+            endpoint="http://service.cn-test.maxcompute.aliyun.com/api",
+            region_name="cn-test",
+            no_validate=True,
+            target_config_path=config_path,
+        )
+
+        assert envelope.status == "success"
+        assert envelope.command == "auth.login-external"
+        assert envelope.data["auth_type"] == "external"
+        assert envelope.data["process_command"] == "/usr/bin/echo '{}'"
+
+        saved = yaml.safe_load(config_path.read_text(encoding="utf-8"))
+        assert saved["auth"]["provider"] == "external"
+        assert saved["auth"]["external"]["process_command"] == "/usr/bin/echo '{}'"
+        assert saved["auth"]["external"]["process_timeout"] == 30
+        assert saved["auth"]["project"] == "proj_x"

{maxc_cli-0.3.1 → 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.1 → 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.1 → maxc_cli-0.3.3}/tests/test_phase1_improvements.py

@@ -572,19 +572,19 @@ class TestParseSqlWithHints:
     def test_multi_statement_injects_script_mode(self):
         from maxc_cli.backend.query import _parse_sql_with_hints
 
-        _, hints = _parse_sql_with_hints("SELECT 1; SELECT 2")
+        _, hints, _ = _parse_sql_with_hints("SELECT 1; SELECT 2")
         assert hints.get("odps.sql.submit.mode") == "script"
 
     def test_single_statement_does_not_inject_script_mode(self):
         from maxc_cli.backend.query import _parse_sql_with_hints
 
-        _, hints = _parse_sql_with_hints("SELECT 1")
+        _, hints, _ = _parse_sql_with_hints("SELECT 1")
         assert "odps.sql.submit.mode" not in hints
 
     def test_user_provided_script_mode_is_preserved(self):
         from maxc_cli.backend.query import _parse_sql_with_hints
 
-        _, hints = _parse_sql_with_hints(
+        _, hints, _ = _parse_sql_with_hints(
             "SET odps.sql.submit.mode=non_script; SELECT 1; SELECT 2"
         )
         # User's value wins
@@ -593,13 +593,13 @@ class TestParseSqlWithHints:
     def test_trailing_semicolon_is_not_treated_as_multistatement(self):
         from maxc_cli.backend.query import _parse_sql_with_hints
 
-        _, hints = _parse_sql_with_hints("SELECT 1;")
+        _, hints, _ = _parse_sql_with_hints("SELECT 1;")
         assert "odps.sql.submit.mode" not in hints
 
     def test_comments_are_not_counted_as_statements(self):
         from maxc_cli.backend.query import _parse_sql_with_hints
 
-        _, hints = _parse_sql_with_hints(
+        _, hints, _ = _parse_sql_with_hints(
             "-- header;\nSELECT 1; -- trailing comment;"
         )
         assert "odps.sql.submit.mode" not in hints
@@ -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:

{maxc_cli-0.3.1 → maxc_cli-0.3.3}/tests/test_setting_parser.py

@@ -91,19 +91,21 @@ def test_set_with_escaped_semicolon():
 
 
 def test_parse_sql_with_hints_default_no_extra_hints():
-    actual_sql, hints = _parse_sql_with_hints("SELECT 1")
+    actual_sql, hints, priority = _parse_sql_with_hints("SELECT 1")
     assert actual_sql == "SELECT 1"
     assert hints == {}
+    assert priority is None
 
 
 def test_parse_sql_with_hints_merges_user_set():
-    actual_sql, hints = _parse_sql_with_hints(
+    actual_sql, hints, priority = _parse_sql_with_hints(
         "SET odps.sql.type.system.odps2=true; SELECT 1"
     )
     assert actual_sql == "SELECT 1"
     assert hints == {
         "odps.sql.type.system.odps2": "true",
     }
+    assert priority is None
 
 
 def test_parse_sql_with_hints_blocks_write_without_force():
@@ -117,13 +119,14 @@ def test_parse_sql_with_hints_blocks_write_without_force():
 
 
 def test_parse_sql_with_hints_force_allows_write():
-    actual_sql, hints = _parse_sql_with_hints("CREATE TABLE t (id BIGINT)", force=True)
+    actual_sql, hints, priority = _parse_sql_with_hints("CREATE TABLE t (id BIGINT)", force=True)
     assert actual_sql == "CREATE TABLE t (id BIGINT)"
     assert hints == {}
+    assert priority is None
 
 
 def test_parse_sql_with_hints_force_preserves_user_sets():
-    actual_sql, hints = _parse_sql_with_hints(
+    actual_sql, hints, _priority = _parse_sql_with_hints(
         "SET odps.sql.type.system.odps2=true; CREATE TABLE t (id BIGINT)",
         force=True,
     )
@@ -136,6 +139,39 @@ def test_parse_sql_with_hints_invalid_set_raises():
         _parse_sql_with_hints("SET no_semicolon SELECT 1")
 
 
+def test_parse_sql_with_hints_extracts_priority():
+    actual_sql, hints, priority = _parse_sql_with_hints(
+        "SET odps.instance.priority=3; SELECT 1"
+    )
+    assert actual_sql == "SELECT 1"
+    assert priority == 3
+    # priority must be stripped from the hints dict — it's a run_sql kwarg, not a SQL hint.
+    assert "odps.instance.priority" not in hints
+
+
+def test_parse_sql_with_hints_priority_case_insensitive_key():
+    _, hints, priority = _parse_sql_with_hints(
+        "SET ODPS.Instance.Priority=5; SELECT 1"
+    )
+    assert priority == 5
+    assert hints == {}
+
+
+def test_parse_sql_with_hints_priority_invalid_raises():
+    with pytest.raises(ValidationError, match="odps.instance.priority"):
+        _parse_sql_with_hints("SET odps.instance.priority=high; SELECT 1")
+
+
+def test_parse_sql_with_hints_priority_coexists_with_other_hints():
+    _, hints, priority = _parse_sql_with_hints(
+        "SET odps.instance.priority=1; "
+        "SET odps.sql.type.system.odps2=true; "
+        "SELECT 1"
+    )
+    assert priority == 1
+    assert hints == {"odps.sql.type.system.odps2": "true"}
+
+
 # --- translate_odps_error readonly detection tests ---