sanka-cli 0.2.1__tar.gz → 0.2.3__tar.gz

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sanka-cli
-Version: 0.2.1
+Version: 0.2.3
 Summary: Sanka command-line interface and migration runtime
 Project-URL: Repository, https://github.com/sankaHQ/sanka
 Project-URL: Issues, https://github.com/sankaHQ/sanka/issues
@@ -54,6 +54,19 @@ uv tool install 'sanka-cli[mcp]'
 sanka mcp
 ```
 
+Install the bundled `sanka-cli` skill into an AI coding harness:
+
+```bash
+sanka skill install claude
+sanka skill install codex --scope project
+sanka skill install --scope global
+```
+
+The command prompts for project or global scope when `--scope` is omitted.
+Without a harness argument, it installs into every detected Claude Code or
+Codex CLI. Existing matching installs are left unchanged; different content
+requires `--force`.
+
 The base tool does not install framework migrations or provider drivers.
 Components are immutable GitHub release wheels selected through the extension
 manager:

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/README.md

@@ -24,6 +24,19 @@ uv tool install 'sanka-cli[mcp]'
 sanka mcp
 ```
 
+Install the bundled `sanka-cli` skill into an AI coding harness:
+
+```bash
+sanka skill install claude
+sanka skill install codex --scope project
+sanka skill install --scope global
+```
+
+The command prompts for project or global scope when `--scope` is omitted.
+Without a harness argument, it installs into every detected Claude Code or
+Codex CLI. Existing matching installs are left unchanged; different content
+requires `--force`.
+
 The base tool does not install framework migrations or provider drivers.
 Components are immutable GitHub release wheels selected through the extension
 manager:

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sanka-cli"
-version = "0.2.1"
+version = "0.2.3"
 description = "Sanka command-line interface and migration runtime"
 readme = "README.md"
 requires-python = ">=3.12"

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/src/sanka/cli/__init__.py

@@ -669,9 +669,51 @@ def _extension_result(
     data = {"operation": operation, "records": records}
     if args.json:
         _print_json(_json_result("extension", data, migration_state="not_started"))
-    else:
-        for record in records:
-            print(json.dumps(record, ensure_ascii=False, sort_keys=True))
+        return 0
+
+    terminal = _terminal(args)
+    if operation == "list":
+        terminal.heading("Extensions")
+        terminal.table(
+            ("Extension", "Kind", "Version", "Status", "Marketplace"),
+            [
+                (
+                    str(record.get("id", "")),
+                    str(record.get("kind", "")),
+                    str(record.get("version", "")),
+                    ", ".join(map(str, record.get("status", []))),
+                    str(record.get("marketplace", "")),
+                )
+                for record in records
+            ],
+        )
+    elif operation == "marketplace_list":
+        terminal.heading("Marketplaces")
+        terminal.table(
+            ("Marketplace", "Source", "Commit", "Trusted"),
+            [
+                (
+                    str(record.get("name", "")),
+                    str(record.get("source", "")),
+                    str(record.get("resolved_commit") or "-")[:12],
+                    "yes" if record.get("trusted") else "no",
+                )
+                for record in records
+            ],
+        )
+    elif operation == "add":
+        record = records[0]
+        terminal.success(f"Installed {record['id']} {record['version']}")
+    elif operation == "remove":
+        terminal.success(f"Removed {records[0]['id']}")
+    elif operation == "marketplace_add":
+        terminal.success(f"Added marketplace {records[0]['name']}")
+    elif operation == "marketplace_upgrade":
+        terminal.success(
+            "Updated marketplace " + ", ".join(str(record["name"]) for record in records)
+        )
+    elif operation == "marketplace_remove":
+        terminal.success(f"Removed marketplace {records[0]['name']}")
     return 0
 
 

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/src/sanka/cli/_output.py

@@ -57,6 +57,24 @@ class TerminalOutput:
         if not self.quiet:
             print(self.style(value, "cyan"), file=self.stdout)
 
+    def table(self, headers: tuple[str, ...], rows: list[tuple[str, ...]]) -> None:
+        if self.quiet:
+            return
+        widths = [
+            max(len(header), *(len(row[index]) for row in rows))
+            for index, header in enumerate(headers)
+        ]
+        print(
+            "  ".join(header.ljust(width) for header, width in zip(headers, widths, strict=True)),
+            file=self.stdout,
+        )
+        print("  ".join("-" * width for width in widths), file=self.stdout)
+        for row in rows:
+            print(
+                "  ".join(value.ljust(width) for value, width in zip(row, widths, strict=True)),
+                file=self.stdout,
+            )
+
     def success(self, value: str) -> None:
         print(self.style(f"✓ OK  {value}", "green"), file=self.stdout)
 

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/src/sanka/runtime/extensions/store.py

@@ -529,6 +529,13 @@ def _create_venv(
     )
 
 
+def _venv_launcher_names() -> tuple[str, ...]:
+    names = ("python", "python3", f"python{sys.version_info.major}.{sys.version_info.minor}")
+    if sys.version_info[:2] == (3, 14) and sys.getfilesystemencoding() == "utf-8":
+        names += ("𝜋thon",)
+    return names
+
+
 def _normalize_venv_launchers(environment_descriptor: int) -> None:
     if os.name == "nt":
         return
@@ -543,10 +550,9 @@ def _normalize_venv_launchers(environment_descriptor: int) -> None:
                 )
             os.unlink("lib64", dir_fd=environment_descriptor)
     interpreter = Path(sys.executable).resolve()
-    names = ("python", "python3", f"python{sys.version_info.major}.{sys.version_info.minor}")
     with _directory_at(environment_descriptor, "bin", Path("bin")) as bin_descriptor:
         assert bin_descriptor is not None
-        for name in names:
+        for name in _venv_launcher_names():
             with suppress(FileNotFoundError):
                 status = os.stat(name, dir_fd=bin_descriptor, follow_symlinks=False)
                 if not (stat.S_ISLNK(status.st_mode) or stat.S_ISREG(status.st_mode)):
@@ -2830,24 +2836,29 @@ class ExtensionStore:
                 missing_ok=True,
             ) as existing:
                 if existing is not None:
-                    digest = content_hash(
-                        _tree_records(
-                            existing,
-                            error_code="SANKA_EXTENSION_PATH",
-                            subject="Extension environment",
-                            allowed_symlinks=self._environment_symlinks(),
-                        )
-                    )
-                    if digest == expected_digest:
-                        try:
-                            self._verify_environment_artifacts(
-                                root, executable, wheels, providers=providers
+                    try:
+                        digest = content_hash(
+                            _tree_records(
+                                existing,
+                                error_code="SANKA_EXTENSION_PATH",
+                                subject="Extension environment",
+                                allowed_symlinks=self._environment_symlinks(),
                             )
-                        except ExtensionError as error:
-                            if error.code != "SANKA_EXTENSION_HASH_MISMATCH":
-                                raise
-                        else:
-                            return root
+                        )
+                    except ExtensionError as error:
+                        if error.code != "SANKA_EXTENSION_PATH" or expected_digest is not None:
+                            raise
+                    else:
+                        if digest == expected_digest:
+                            try:
+                                self._verify_environment_artifacts(
+                                    root, executable, wheels, providers=providers
+                                )
+                            except ExtensionError as error:
+                                if error.code != "SANKA_EXTENSION_HASH_MISMATCH":
+                                    raise
+                            else:
+                                return root
                     replace_existing = True
             if replace_existing:
                 shutil.rmtree(environment_name, dir_fd=environments)
@@ -3212,11 +3223,7 @@ class ExtensionStore:
     def _environment_symlinks() -> dict[str, Path]:
         interpreter = Path(sys.executable).resolve()
         return dict.fromkeys(
-            (
-                "bin/python",
-                "bin/python3",
-                f"bin/python{sys.version_info.major}.{sys.version_info.minor}",
-            ),
+            (f"bin/{name}" for name in _venv_launcher_names()),
             interpreter,
         )
 

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/src/sanka_cli/__init__.py

@@ -1,4 +1,4 @@
 # SPDX-License-Identifier: Apache-2.0
 __all__ = ["__version__"]
 
-__version__ = "0.2.1"
+__version__ = "0.2.3"

sanka_cli-0.2.3/src/sanka_cli/commands/skill.py

@@ -0,0 +1,146 @@
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import hashlib
+import os
+import shutil
+import tempfile
+from importlib import resources
+from pathlib import Path
+
+import click
+
+import sanka_cli.runtime as runtime
+from sanka_cli.state import CLIState
+
+SKILL_NAME = "sanka-cli"
+HARNESSES = ("claude", "codex")
+CONFIG_ROOTS = {
+    "claude": ("CLAUDE_CONFIG_DIR", ".claude"),
+    "codex": ("CODEX_HOME", ".codex"),
+}
+
+
+def _skill_content() -> bytes:
+    return resources.files("sanka_cli").joinpath("skills", SKILL_NAME, "SKILL.md").read_bytes()
+
+
+def _target_directory(harness: str, scope: str, project_directory: Path) -> Path:
+    environment_name, default_directory = CONFIG_ROOTS[harness]
+    if scope == "project":
+        root = project_directory.resolve() / f".{harness}"
+    else:
+        configured_root = os.environ.get(environment_name)
+        root = (
+            Path(configured_root).expanduser()
+            if configured_root
+            else Path.home() / default_directory
+        )
+    return root / "skills" / SKILL_NAME
+
+
+def _reject_project_symlinks(project_directory: Path, target: Path) -> None:
+    current = project_directory.resolve()
+    for part in (*target.relative_to(current).parts, "SKILL.md"):
+        current /= part
+        if current.is_symlink():
+            raise click.ClickException(
+                f"Refusing project installation through symbolic link: {current}"
+            )
+
+
+def _planned_status(target: Path, content: bytes, *, force: bool) -> str:
+    skill_file = target / "SKILL.md"
+    try:
+        if skill_file.is_file() and skill_file.read_bytes() == content:
+            return "unchanged"
+        if target.exists() and not force:
+            raise click.ClickException(
+                f"{target} already exists with different content; "
+                "rerun with --force to replace SKILL.md."
+            )
+        return "updated" if target.exists() else "installed"
+    except OSError as exc:
+        raise click.ClickException(f"Could not inspect {target}: {exc}") from exc
+
+
+def _write_skill(target: Path, content: bytes) -> None:
+    temporary_path: Path | None = None
+    try:
+        target.mkdir(parents=True, exist_ok=True)
+        with tempfile.NamedTemporaryFile(
+            mode="wb", dir=target, prefix=".SKILL.md.", delete=False
+        ) as file:
+            file.write(content)
+            temporary_path = Path(file.name)
+        os.replace(temporary_path, target / "SKILL.md")
+    except OSError as exc:
+        raise click.ClickException(f"Could not install {SKILL_NAME} at {target}: {exc}") from exc
+    finally:
+        if temporary_path is not None:
+            temporary_path.unlink(missing_ok=True)
+
+
+@click.group()
+def skill() -> None:
+    """Install Sanka skills into supported AI coding harnesses."""
+
+
+@skill.command("install")
+@click.argument("harness", required=False, type=click.Choice(HARNESSES))
+@click.option("--scope", type=click.Choice(["project", "global"]), default=None)
+@click.option(
+    "--project-dir",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    default=Path("."),
+    show_default=True,
+)
+@click.option("--force", is_flag=True, help="Replace a different installed SKILL.md.")
+@click.pass_obj
+def install_skill(
+    state: CLIState,
+    harness: str | None,
+    scope: str | None,
+    project_dir: Path,
+    force: bool,
+) -> None:
+    """Install the sanka-cli skill for Claude Code, Codex, or detected harnesses."""
+    harnesses = [harness] if harness else [name for name in HARNESSES if shutil.which(name)]
+    if not harnesses:
+        raise click.ClickException(
+            "No supported harness detected. Pass `claude` or `codex` explicitly."
+        )
+    resolved_scope = scope or click.prompt(
+        "Install scope",
+        type=click.Choice(["project", "global"]),
+        default="project",
+        err=True,
+    )
+    content = _skill_content()
+    plans: list[tuple[str, Path, str]] = []
+    for harness_name in harnesses:
+        target = _target_directory(harness_name, resolved_scope, project_dir)
+        if resolved_scope == "project":
+            _reject_project_symlinks(project_dir, target)
+        plans.append((harness_name, target, _planned_status(target, content, force=force)))
+
+    installations = []
+    for harness_name, target, status in plans:
+        if status != "unchanged":
+            _write_skill(target, content)
+        installations.append(
+            {
+                "harness": harness_name,
+                "path": str(target),
+                "status": status,
+            }
+        )
+    runtime.emit_payload(
+        {
+            "skill": SKILL_NAME,
+            "scope": resolved_scope,
+            "content_sha256": hashlib.sha256(content).hexdigest(),
+            "installations": installations,
+        },
+        state,
+    )

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/src/sanka_cli/main.py

@@ -10,6 +10,7 @@ from sanka_cli.commands.code import code
 from sanka_cli.commands.migrate import register_migration_passthroughs
 from sanka_cli.commands.profiles import profiles
 from sanka_cli.commands.resources import attach_resource_group
+from sanka_cli.commands.skill import skill
 from sanka_cli.commands.workflows import workflows
 from sanka_cli.output import print_error
 from sanka_cli.state import CLIState
@@ -43,6 +44,7 @@ cli.add_command(profiles)
 cli.add_command(workflows)
 cli.add_command(ai)
 cli.add_command(code)
+cli.add_command(skill)
 
 attach_resource_group(cli, "companies", "/v2/public/companies")
 attach_resource_group(cli, "contacts", "/v2/public/contacts")

sanka_cli-0.2.3/src/sanka_cli/skills/sanka-cli/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: sanka-cli
+description: Use when inspecting, planning, applying, testing, verifying, or monitoring application and data migrations with the sanka command-line interface.
+---
+
+# Sanka CLI
+
+Use `sanka` for application modernization and data movement. Derive the migration mode and destination from the user's task; never assume FastAPI or any other target.
+
+## Choose the migration mode
+
+Run `sanka --help`, the selected command's `--help`, and `sanka extension list --json` before choosing options. Do not guess target names, component IDs, or flags.
+
+- **Application migration:** a source repository is converted to a task-selected framework or runtime. Use target-specific flags only when the task and command help require them.
+- **Data migration:** records move between task-selected systems described by `sanka.yaml`. Use environment references for credentials and install only the required trusted extensions after authorization.
+
+## Application migration
+
+```bash
+sanka scan . --json
+sanka plan . --json
+sanka apply --root . --plan-hash <reviewed-plan-hash> --json
+sanka test . --json
+sanka verify . --json
+```
+
+Add task-specific plan, output, or target options from `sanka plan --help`; the sequence does not imply a particular destination.
+
+## Data migration
+
+Define the source and target in `sanka.yaml`. This is the basic shape; use exact types and options reported by installed extensions:
+
+```yaml
+source:
+  type: <source-type>
+  connection: <path-or-environment-reference>
+target:
+  type: <target-type>
+  connection: <path-or-environment-reference>
+```
+
+Then run:
+
+```bash
+sanka plan --json
+sanka validate --json
+sanka apply --plan-hash <reviewed-plan-hash> --json
+sanka verify --json
+sanka status
+```
+
+`validate` checks source records against the plan without writing to the destination. Review its result before applying. Use `sanka extension --help` when a required source, target, or migration capability is not installed.
+
+## Safety boundary
+
+- Planning must not write to the destination. Review the source, target, mappings, readiness, limitations, output path, and exact `plan_hash`.
+- Get explicit user authorization immediately before `apply`; apply only the reviewed hash.
+- Treat source behavior and the task contract as authoritative. Generated applications require parity verification; data `apply` performs real destination writes.
+- If pre-write testing or validation fails, fix the plan or configuration and re-plan. If post-write verification fails, inspect `status`; never rerun `apply` blindly. Any changed plan requires review and authorization of its new hash.
+- Never silently switch between local and hosted execution. Use the configured profile only when the task selects hosted operation.
+- Use `--bench-candidate <path>` on `sanka apply` only when a benchmark task requests that artifact layout.
+- Do not expose credentials in command arguments, logs, generated files, or reports.

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/tests/test_cli.py

@@ -163,6 +163,73 @@ def test_extension_management_uses_stable_json_envelopes(
     ]
 
 
+def test_extension_lists_use_human_readable_tables(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    class Record:
+        def __init__(self, data: dict[str, object]) -> None:
+            self.data = data
+
+        def to_dict(self) -> dict[str, object]:
+            return self.data
+
+    class Store:
+        def __init__(self, project_root: Path) -> None:
+            assert project_root == tmp_path
+
+        def list_extensions(self) -> tuple[Record, ...]:
+            return (
+                Record(
+                    {
+                        "id": "sanka/drf-to-fastapi",
+                        "kind": "migration",
+                        "version": "0.1.0a3",
+                        "status": ["installed", "enabled"],
+                        "marketplace": "official",
+                        "wheels": [{"sha256": "secret-noise"}],
+                    }
+                ),
+            )
+
+        def marketplaces(self) -> tuple[Record, ...]:
+            return (
+                Record(
+                    {
+                        "name": "official",
+                        "source": "https://github.com/sankaHQ/extensions.git",
+                        "resolved_commit": "a44ab1794924d45e8eeaeec456ce5c28c1c17d56",
+                        "trusted": True,
+                        "snapshot_root": "/private/cache/noise",
+                    }
+                ),
+            )
+
+    monkeypatch.chdir(tmp_path)
+    monkeypatch.setattr(cli, "ExtensionStore", Store)
+
+    assert main(["extension", "list", "--no-color"]) == 0
+    extensions = capsys.readouterr().out
+    assert "Extension" in extensions
+    assert "sanka/drf-to-fastapi" in extensions
+    assert "installed, enabled" in extensions
+    assert "wheels" not in extensions
+    assert "secret-noise" not in extensions
+    assert not extensions.lstrip().startswith("{")
+
+    assert main(["extension", "marketplace", "list", "--no-color"]) == 0
+    marketplaces = capsys.readouterr().out
+    assert "Marketplace" in marketplaces
+    assert "official" in marketplaces
+    assert "github.com/sankaHQ/extensions" in marketplaces
+    assert "a44ab179492" in marketplaces
+    assert "yes" in marketplaces
+    assert "snapshot_root" not in marketplaces
+    assert "private/cache/noise" not in marketplaces
+    assert not marketplaces.lstrip().startswith("{")
+
+
 def test_extension_errors_preserve_stable_code_and_details(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -550,7 +617,7 @@ def test_research_client_uses_public_branded_base_and_unwraps_data() -> None:
         "after": ["2027-01"],
         "locale": ["ja"],
     }
-    assert request.get_header("User-agent") == "sanka-cli/0.2.1"
+    assert request.get_header("User-agent") == "sanka-cli/0.2.3"
     assert timeout == 10.0
 
 

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/tests/test_extension_store.py

@@ -1748,6 +1748,82 @@ def test_venv_normalization_rejects_a_nonstandard_lib64_alias(tmp_path: Path) ->
         os.close(descriptor)
 
 
+@pytest.mark.skipif(os.name != "posix", reason="POSIX venv launcher sealing only")
+def test_venv_normalization_accepts_python_314_unicode_launcher(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    environment = tmp_path / "environment"
+    (environment / "bin").mkdir(parents=True)
+    (environment / "bin" / "𝜋thon").symlink_to("python3.14")
+
+    class VersionInfo(tuple[object, ...]):
+        major = 3
+        minor = 14
+
+    version_info = VersionInfo((3, 14, 0, "final", 0))
+    monkeypatch.setattr(sys, "version_info", version_info)
+    monkeypatch.setattr(sys, "getfilesystemencoding", lambda: "utf-8")
+
+    descriptor = os.open(environment, os.O_RDONLY)
+    try:
+        extension_store._normalize_venv_launchers(descriptor)
+        extension_store._tree_records(
+            descriptor,
+            error_code="SANKA_EXTENSION_PATH",
+            subject="Extension environment",
+            allowed_symlinks=ExtensionStore._environment_symlinks(),
+        )
+    finally:
+        os.close(descriptor)
+
+    launcher = environment / "bin" / "𝜋thon"
+    assert launcher.is_symlink()
+    assert Path(os.readlink(launcher)) == Path(sys.executable).resolve()
+
+
+@pytest.mark.skipif(os.name != "posix", reason="POSIX venv launcher sealing only")
+def test_add_rebuilds_an_orphaned_environment_with_an_unverified_symlink(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    source, wheel = _marketplace(tmp_path / "source")
+    store = ExtensionStore(tmp_path / "project", user_root=tmp_path / "home")
+    store.add_marketplace(source, name="fixtures", trust=True)
+    manifest = load_marketplace(store.marketplaces()[0].snapshot_root)[0]
+    _responses(monkeypatch, {manifest.wheels[0].name: wheel})
+    environment = store.user_root / "environments" / store._manifest_artifact_digest(manifest)
+    (environment / "bin").mkdir(parents=True)
+    stale_launcher = environment / "bin" / "stale-python"
+    stale_launcher.symlink_to("python")
+
+    lock = store.add_extension("example/demo")
+
+    assert lock.artifact_digest == environment.name
+    assert not stale_launcher.exists() and not stale_launcher.is_symlink()
+    assert store.resolve_locked("example/demo") == lock
+
+
+@pytest.mark.skipif(os.name != "posix", reason="POSIX venv launcher sealing only")
+def test_add_rejects_an_unverified_symlink_in_a_recorded_environment(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    source, wheel = _marketplace(tmp_path / "source")
+    store = ExtensionStore(tmp_path / "project", user_root=tmp_path / "home")
+    store.add_marketplace(source, name="fixtures", trust=True)
+    manifest = load_marketplace(store.marketplaces()[0].snapshot_root)[0]
+    _responses(monkeypatch, {manifest.wheels[0].name: wheel})
+    lock = store.add_extension("example/demo")
+    stale_launcher = (
+        store.user_root / "environments" / lock.artifact_digest / "bin" / "stale-python"
+    )
+    stale_launcher.symlink_to("python")
+
+    with pytest.raises(ExtensionError) as raised:
+        store.add_extension("example/demo")
+
+    assert raised.value.code == "SANKA_EXTENSION_PATH"
+    assert stale_launcher.is_symlink()
+
+
 @pytest.mark.skipif(os.name != "posix", reason="POSIX venv launcher sealing only")
 def test_real_posix_materializer_installs_without_a_venv_test_hook(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/tests/test_mcp.py

@@ -21,7 +21,7 @@ def test_root_version_uses_unified_public_version(runner: CliRunner) -> None:
     result = runner.invoke(cli, ["--version"])
 
     assert result.exit_code == 0
-    assert result.output == "sanka, version 0.2.1\n"
+    assert result.output == "sanka, version 0.2.3\n"
 
 
 def test_mcp_client_uses_the_cli_version_in_its_user_agent() -> None:
@@ -29,7 +29,7 @@ def test_mcp_client_uses_the_cli_version_in_its_user_agent() -> None:
 
     client = SankaMigrateApiClient()
 
-    assert client._client.headers["User-Agent"] == "sanka-cli/0.2.1"
+    assert client._client.headers["User-Agent"] == "sanka-cli/0.2.3"
 
 
 def test_mcp_without_extra_has_install_hint(

{sanka_cli-0.2.1 → sanka_cli-0.2.3}/tests/test_sanka_facade.py

@@ -35,7 +35,7 @@ def test_public_facade_version_matches_unified_distribution() -> None:
         == sanka_cli.__version__
         == sanka_cli.mcp.__version__
         == distribution_version("sanka-cli")
-        == "0.2.1"
+        == "0.2.3"
     )