stackops 8.104__tar.gz → 26.6__tar.gz

{stackops-8.104/src/stackops.egg-info → stackops-26.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackops
-Version: 8.104
+Version: 26.6
 Summary: Developer Stack Manager
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0

{stackops-8.104 → stackops-26.6}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackops"
-version = "8.104"
+version = "26.6"
 description = "Developer Stack Manager"
 readme = "README.md"
 license = {text = "Apache 2.0"}

stackops-26.6/src/manual/test_agents_skill_impl.py

@@ -0,0 +1,44 @@
+from pathlib import Path
+
+import pytest
+
+from stackops.scripts.python.helpers.helpers_agents.agents_skill_impl import (
+    build_agent_skill_install_commands,
+    is_supported_agent_skill_name,
+    parse_requested_skill_agent_targets,
+    render_agent_skill_install_script,
+    supported_agent_skill_names,
+)
+
+
+def test_stackops_skill_is_supported() -> None:
+    assert is_supported_agent_skill_name(skill_name="stackops")
+    assert "stackops" in supported_agent_skill_names()
+
+
+def test_stackops_skill_install_command_selects_repo_skill() -> None:
+    assert build_agent_skill_install_commands(skill_names=("stackops",), agent_targets=(), scope="local") == (
+        ("bunx", "skills@latest", "add", "https://github.com/thisismygitrepo/stackops", "--skill", "stackops", "--yes"),
+    )
+
+
+def test_existing_skill_install_command_shape_is_preserved() -> None:
+    assert build_agent_skill_install_commands(skill_names=("caveman",), agent_targets=("codex",), scope="global") == (
+        ("bunx", "skills@latest", "add", "JuliusBrussee/caveman", "--yes", "--global", "--agent", "codex"),
+    )
+
+
+def test_agent_targets_are_comma_separated_without_empty_entries() -> None:
+    assert parse_requested_skill_agent_targets(raw_value="codex,github-copilot") == ("codex", "github-copilot")
+    with pytest.raises(ValueError, match="without empty entries"):
+        parse_requested_skill_agent_targets(raw_value="codex,")
+
+
+def test_render_install_script_quotes_install_root() -> None:
+    script = render_agent_skill_install_script(
+        install_root=Path("/tmp/StackOps Skills"),
+        commands=build_agent_skill_install_commands(skill_names=("stackops",), agent_targets=("codex",), scope="local"),
+    )
+
+    assert script.startswith("cd '/tmp/StackOps Skills'\n")
+    assert "bunx skills@latest add https://github.com/thisismygitrepo/stackops --skill stackops --yes --agent codex" in script

{stackops-8.104 → stackops-26.6}/src/manual/test_cli_config_secrets.py

@@ -7,6 +7,7 @@ import pytest
 from typer.testing import CliRunner
 
 from stackops.scripts.python.helpers.helpers_devops import cli_config, cli_config_secrets
+from stackops.scripts.python.helpers.helpers_devops.cli_config_secrets_interactive import InteractivePickerOption
 
 
 def test_config_secrets_is_nested_typer_app() -> None:
@@ -75,6 +76,7 @@ def test_secrets_add_and_edit_have_short_aliases() -> None:
     assert "-p" in _option_param_decls(subset_parameters["secrets_path"])
     assert "-s" in _option_param_decls(subset_parameters["secrets_source"])
     assert "-f" in _option_param_decls(subset_parameters["overwrite"])
+    assert "-P" in _option_param_decls(subset_parameters["preview_secrets"])
     assert "-p" in _option_param_decls(add_parameters["secrets_path"])
     assert "-s" in _option_param_decls(add_parameters["secrets_source"])
     assert "-p" in _option_param_decls(edit_parameters["secrets_path"])
@@ -199,7 +201,11 @@ def test_secrets_subset_writes_selected_entries_without_printing_secret_values(t
         ),
         encoding="utf-8",
     )
-    monkeypatch.setattr(cli_config_secrets.secret_actions, "_choose_subset_login_indices", lambda secrets_file: [1])
+    monkeypatch.setattr(
+        cli_config_secrets.secret_actions,
+        "_choose_subset_login_indices",
+        lambda *, secrets_file, source_path, preview_secrets: [1],
+    )
     runner = CliRunner()
 
     result = runner.invoke(
@@ -239,7 +245,11 @@ def test_secrets_subset_refuses_to_overwrite_by_default(tmp_path: Path, monkeypa
         encoding="utf-8",
     )
     output_path.write_text("existing\n", encoding="utf-8")
-    monkeypatch.setattr(cli_config_secrets.secret_actions, "_choose_subset_login_indices", lambda secrets_file: [0])
+    monkeypatch.setattr(
+        cli_config_secrets.secret_actions,
+        "_choose_subset_login_indices",
+        lambda *, secrets_file, source_path, preview_secrets: [0],
+    )
     runner = CliRunner()
 
     result = runner.invoke(
@@ -251,6 +261,127 @@ def test_secrets_subset_refuses_to_overwrite_by_default(tmp_path: Path, monkeypa
     assert output_path.read_text(encoding="utf-8") == "existing\n"
 
 
+def test_secrets_subset_preview_matches_search_style_without_secret_values(tmp_path: Path) -> None:
+    source_path = tmp_path / "source-secrets.json"
+    output_path = tmp_path / "subset-secrets.json"
+    source_path.write_text(
+        json.dumps(
+            {
+                "version": "0.5",
+                "entries": [
+                    {
+                        "name": "shared-login",
+                        "tags": ["team-a"],
+                        "secrets": [
+                            {
+                                "name": "first-token",
+                                "tags": ["api"],
+                                "scopes": ["dev"],
+                                "keyValues": {"FIRST_TOKEN": "first-secret-value"},
+                            },
+                            {
+                                "name": "second-token",
+                                "tags": ["ops"],
+                                "scopes": ["prod"],
+                                "keyValues": {"SECOND_TOKEN": "second-secret-value"},
+                            },
+                        ],
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+    captured_picker_options: list[InteractivePickerOption[int]] = []
+
+    def capture_picker_options(
+        options: list[InteractivePickerOption[int]],
+        *,
+        missing_tool_message: str,
+        missing_selection_message: str,
+    ) -> list[int]:
+        assert missing_tool_message == "Interactive subset selection requires `tv` on PATH."
+        assert missing_selection_message == "Interactive selection did not map to a secrets entry"
+        captured_picker_options.extend(options)
+        return [0]
+
+    monkeypatch = pytest.MonkeyPatch()
+    monkeypatch.setattr(cli_config_secrets.secret_actions, "choose_interactive_options", capture_picker_options)
+    try:
+        result = CliRunner().invoke(
+            cli_config_secrets.get_app(),
+            ["subset", "--path", str(source_path), "--source", "local", "--output", str(output_path)],
+        )
+    finally:
+        monkeypatch.undo()
+
+    assert result.exit_code == 0
+    assert len(captured_picker_options) == 1
+    assert captured_picker_options[0].label == "shared-login -> FIRST_TOKEN, SECOND_TOKEN"
+    assert "# shared-login -> FIRST_TOKEN, SECOND_TOKEN" in captured_picker_options[0].preview
+    assert f"- File: `{source_path}`" in captured_picker_options[0].preview
+    assert "- Login: `shared-login`" in captured_picker_options[0].preview
+    assert "- Env vars: `FIRST_TOKEN, SECOND_TOKEN`" in captured_picker_options[0].preview
+    assert "### first-token" in captured_picker_options[0].preview
+    assert "### second-token" in captured_picker_options[0].preview
+    assert "first-secret-value" not in captured_picker_options[0].preview
+    assert "second-secret-value" not in captured_picker_options[0].preview
+
+
+def test_secrets_subset_preview_secrets_includes_login_entry_json(tmp_path: Path) -> None:
+    source_path = tmp_path / "source-secrets.json"
+    output_path = tmp_path / "subset-secrets.json"
+    source_path.write_text(
+        json.dumps(
+            {
+                "version": "0.5",
+                "entries": [
+                    {
+                        "name": "shared-login",
+                        "tags": ["team-a"],
+                        "secrets": [
+                            {
+                                "name": "first-token",
+                                "tags": ["api"],
+                                "scopes": ["dev"],
+                                "keyValues": {"FIRST_TOKEN": "first-secret-value"},
+                            }
+                        ],
+                    }
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+    captured_picker_options: list[InteractivePickerOption[int]] = []
+
+    def capture_picker_options(
+        options: list[InteractivePickerOption[int]],
+        *,
+        missing_tool_message: str,
+        missing_selection_message: str,
+    ) -> list[int]:
+        assert missing_tool_message == "Interactive subset selection requires `tv` on PATH."
+        assert missing_selection_message == "Interactive selection did not map to a secrets entry"
+        captured_picker_options.extend(options)
+        return [0]
+
+    monkeypatch = pytest.MonkeyPatch()
+    monkeypatch.setattr(cli_config_secrets.secret_actions, "choose_interactive_options", capture_picker_options)
+    try:
+        result = CliRunner().invoke(
+            cli_config_secrets.get_app(),
+            ["subset", "--path", str(source_path), "--source", "local", "--output", str(output_path), "--preview-secrets"],
+        )
+    finally:
+        monkeypatch.undo()
+
+    assert result.exit_code == 0
+    assert len(captured_picker_options) == 1
+    assert "## Login entry" in captured_picker_options[0].preview
+    assert '"FIRST_TOKEN": "first-secret-value"' in captured_picker_options[0].preview
+
+
 def _option_param_decls(parameter: Parameter) -> tuple[str, ...]:
     for metadata in get_args(parameter.annotation)[1:]:
         param_decls = getattr(metadata, "param_decls", ())

stackops-26.6/src/manual/test_cli_self_clone.py

@@ -0,0 +1,58 @@
+from inspect import Parameter, signature
+from pathlib import Path
+from typing import get_args
+
+from typer.testing import CliRunner
+
+from stackops.scripts.python.helpers.helpers_devops import cli_self
+
+
+def test_self_clone_command_is_registered() -> None:
+    runner = CliRunner()
+
+    help_result = runner.invoke(cli_self.get_app(), ["--help"])
+    alias_result = runner.invoke(cli_self.get_app(), ["c", "--help"])
+
+    assert help_result.exit_code == 0
+    assert "clone" in help_result.stdout
+    assert "<c>" in help_result.stdout
+    assert alias_result.exit_code == 0
+    assert "--remote" in alias_result.stdout
+    assert "--dry-run" in alias_result.stdout
+
+
+def test_self_clone_options_have_nice_aliases() -> None:
+    parameters = signature(cli_self.clone).parameters
+    expected_aliases = {
+        "remote": "-r",
+        "branch": "-b",
+        "depth": "-d",
+        "pull": "-p",
+        "install_editable": "-i",
+        "dry_run": "-n",
+    }
+
+    for parameter_name, alias in expected_aliases.items():
+        assert alias in _option_param_decls(parameters[parameter_name])
+
+
+def test_self_clone_defaults_to_current_directory(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+
+    result = CliRunner().invoke(
+        cli_self.get_app(),
+        ["clone", "--dry-run", "--ssh", "--branch", "main", "--depth", "1"],
+    )
+
+    assert result.exit_code == 0
+    assert f"git clone --branch main --depth 1 git@github.com:thisismygitrepo/stackops.git {tmp_path}" in result.stdout
+    assert "Dry run only" in result.stdout
+    assert not tmp_path.joinpath(".git").exists()
+
+
+def _option_param_decls(parameter: Parameter) -> tuple[str, ...]:
+    for metadata in get_args(parameter.annotation)[1:]:
+        param_decls = getattr(metadata, "param_decls", ())
+        if param_decls:
+            return tuple(param_decls)
+    raise AssertionError(f"Parameter has no Typer option metadata: {parameter.name}")

stackops-26.6/src/manual/test_cli_short_options.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import ast
+from collections import defaultdict
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SOURCE_ROOT = REPO_ROOT / "src" / "stackops"
+
+
+def test_typer_options_have_single_letter_short_aliases_only() -> None:
+    failures: list[str] = []
+
+    for path in sorted(SOURCE_ROOT.rglob("*.py")):
+        tree = ast.parse(path.read_text(encoding="utf-8"), filename=path.as_posix())
+        visitor = _TyperOptionVisitor(path=path.relative_to(REPO_ROOT))
+        visitor.visit(tree)
+        failures.extend(visitor.failures)
+
+    assert failures == []
+
+
+def test_checked_in_cli_hierarchy_short_names_are_single_letter() -> None:
+    failures: list[str] = []
+    for path in [
+        SOURCE_ROOT / "utils" / "cli_utils" / "hierarchy.py",
+        SOURCE_ROOT / "utils" / "cli_utils" / "hierarchy_types.py",
+    ]:
+        tree = ast.parse(path.read_text(encoding="utf-8"), filename=path.as_posix())
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.Dict):
+                continue
+            for key, value in zip(node.keys, node.values, strict=False):
+                if _string_literal_value(key) != "short_name":
+                    continue
+                short_name = _literal_string_value(value)
+                if short_name is not None and len(short_name) != 1:
+                    failures.append(f"{path.relative_to(REPO_ROOT)}:{value.lineno} short_name is not one letter: {short_name!r}")
+
+    assert failures == []
+
+
+class _TyperOptionVisitor(ast.NodeVisitor):
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self.function_stack: list[str] = []
+        self.option_declarations_by_function: dict[str, list[_OptionDeclaration]] = defaultdict(list)
+        self.failures: list[str] = []
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        self.function_stack.append(node.name)
+        self.generic_visit(node)
+        function_name = ".".join(self.function_stack)
+        self._record_duplicate_short_aliases(function_name=function_name)
+        self.function_stack.pop()
+
+    def visit_Call(self, node: ast.Call) -> None:
+        self._check_hidden_command_alias(node)
+        if _is_typer_option_call(node):
+            option_strings = [value for arg in node.args if (value := _string_literal_value(arg)) is not None]
+            short_aliases = [part for option in option_strings for part in _short_option_parts(option)]
+            one_letter_aliases = [alias for alias in short_aliases if len(alias) == 2]
+            multi_letter_aliases = [alias for alias in short_aliases if len(alias) > 2]
+            function_name = ".".join(self.function_stack) or "<module>"
+            declaration = _OptionDeclaration(lineno=node.lineno, function_name=function_name, option_strings=option_strings, short_aliases=one_letter_aliases)
+            self.option_declarations_by_function[function_name].append(declaration)
+
+            if not one_letter_aliases:
+                self.failures.append(f"{self.path}:{node.lineno} {function_name} has no one-letter short alias: {option_strings}")
+            if multi_letter_aliases:
+                self.failures.append(f"{self.path}:{node.lineno} {function_name} has multi-letter short alias: {multi_letter_aliases}")
+
+        self.generic_visit(node)
+
+    def _check_hidden_command_alias(self, node: ast.Call) -> None:
+        if not _is_typer_command_or_group_call(node):
+            return
+        if not _is_hidden_call(node):
+            return
+        command_name = _command_or_group_name(node)
+        if command_name is not None and len(command_name) != 1:
+            function_name = ".".join(self.function_stack) or "<module>"
+            self.failures.append(f"{self.path}:{node.lineno} {function_name} hidden command alias is not one letter: {command_name!r}")
+
+    def _record_duplicate_short_aliases(self, function_name: str) -> None:
+        declarations = self.option_declarations_by_function.get(function_name, [])
+        aliases_to_declarations: dict[str, list[_OptionDeclaration]] = defaultdict(list)
+        for declaration in declarations:
+            for alias in declaration.short_aliases:
+                aliases_to_declarations[alias].append(declaration)
+
+        for alias, alias_declarations in aliases_to_declarations.items():
+            if len(alias_declarations) < 2:
+                continue
+            locations = ", ".join(f"line {declaration.lineno}: {declaration.option_strings}" for declaration in alias_declarations)
+            self.failures.append(f"{self.path} {function_name} duplicates {alias}: {locations}")
+
+
+class _OptionDeclaration:
+    def __init__(self, *, lineno: int, function_name: str, option_strings: list[str], short_aliases: list[str]) -> None:
+        self.lineno = lineno
+        self.function_name = function_name
+        self.option_strings = option_strings
+        self.short_aliases = short_aliases
+
+
+def _is_typer_option_call(node: ast.AST) -> bool:
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and node.func.attr == "Option"
+        and isinstance(node.func.value, ast.Name)
+        and node.func.value.id == "typer"
+    )
+
+
+def _is_typer_command_or_group_call(node: ast.AST) -> bool:
+    return isinstance(node.func, ast.Attribute) and node.func.attr in {"command", "add_typer"}
+
+
+def _is_hidden_call(node: ast.Call) -> bool:
+    for keyword in node.keywords:
+        if keyword.arg == "hidden" and isinstance(keyword.value, ast.Constant):
+            return keyword.value.value is True
+    return False
+
+
+def _command_or_group_name(node: ast.Call) -> str | None:
+    if node.args and (value := _string_literal_value(node.args[0])) is not None:
+        return value
+    for keyword in node.keywords:
+        if keyword.arg == "name":
+            return _string_literal_value(keyword.value)
+    return None
+
+
+def _string_literal_value(node: ast.AST) -> str | None:
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        return node.value
+    return None
+
+
+def _literal_string_value(node: ast.AST) -> str | None:
+    value = _string_literal_value(node)
+    if value is not None:
+        return value
+    if isinstance(node, ast.Subscript) and isinstance(node.value, ast.Name) and node.value.id == "Literal":
+        return _string_literal_value(node.slice)
+    return None
+
+
+def _short_option_parts(option_string: str) -> list[str]:
+    if not option_string.startswith("-") or option_string.startswith("--"):
+        return []
+    return [part for part in option_string.split("/") if part.startswith("-") and not part.startswith("--")]

stackops-26.6/src/manual/test_offline_installer_paths.py

@@ -0,0 +1,104 @@
+from inspect import signature
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from stackops.jobs.scripts_dynamic import download_stackops_offline_installer
+from stackops.scripts.python.helpers.helpers_devops import cli_self
+from stackops.utils.installer_utils import installer_offline_constants, installer_offline_publish
+
+
+def test_offline_installer_defaults_live_under_stackops_config_root() -> None:
+    expected_output_root = Path.home().joinpath(".config", "stackops", "offline_installers")
+
+    assert installer_offline_constants.DEFAULT_OUTPUT_ROOT == expected_output_root
+    assert signature(cli_self.export).parameters["output_root"].default == expected_output_root
+    assert download_stackops_offline_installer.DEFAULT_OUTPUT_DIR == expected_output_root / "stackops-offline-installer"
+
+
+def test_offline_installer_upload_mirrors_home_relative_output_path(tmp_path: Path, monkeypatch) -> None:
+    captured_remote_paths: list[Path] = []
+    url_map_path = tmp_path / "download_stackops_offline_installer.json"
+    url_map_path.write_text("{}\n", encoding="utf-8")
+
+    def fake_to_cloud(
+        *,
+        local_path: Path,
+        cloud: str,
+        remote_path: Path,
+        share: bool,
+        verbose: bool,
+        transfers: int,
+    ) -> str:
+        _ = local_path, cloud, share, verbose, transfers
+        captured_remote_paths.append(remote_path)
+        return "https://drive.google.com/file/d/example/view"
+
+    monkeypatch.setattr(installer_offline_publish.rclone_wrapper, "to_cloud", fake_to_cloud)
+    monkeypatch.setattr(installer_offline_publish, "_resolve_url_map_path", lambda: url_map_path)
+
+    archive_path = installer_offline_constants.DEFAULT_OUTPUT_ROOT / "stackops-offline-installer-linux-x86_64.zip"
+
+    installer_offline_publish.publish_archive(archive_path=archive_path, system_name="Linux", arch_name="x86_64")
+
+    assert captured_remote_paths == [
+        Path("myhome/generic_os/.config/stackops/offline_installers/stackops-offline-installer-linux-x86_64.zip")
+    ]
+
+
+def test_self_download_installer_command_is_registered() -> None:
+    runner = CliRunner()
+
+    help_result = runner.invoke(cli_self.get_app(), ["download-installer", "--help"])
+    alias_result = runner.invoke(cli_self.get_app(), ["D", "--help"])
+
+    assert help_result.exit_code == 0
+    assert "--target" in help_result.stdout
+    assert "--output-dir" in help_result.stdout
+    assert alias_result.exit_code == 0
+    assert "--target" in alias_result.stdout
+
+
+def test_self_download_installer_invokes_dynamic_downloader(tmp_path: Path, monkeypatch) -> None:
+    captured: dict[str, object] = {}
+
+    def fake_download_installer(*, target_key: str | None, output_dir: Path | None) -> Path:
+        captured["target_key"] = target_key
+        captured["output_dir"] = output_dir
+        return output_dir or tmp_path
+
+    monkeypatch.setattr(download_stackops_offline_installer, "download_installer", fake_download_installer)
+
+    result = CliRunner().invoke(
+        cli_self.get_app(),
+        ["download-installer", "--target", "linux-x64", "--output-dir", str(tmp_path)],
+    )
+
+    assert result.exit_code == 0
+    assert captured == {"target_key": "linux-x64", "output_dir": tmp_path}
+
+
+def test_dynamic_downloader_supports_non_interactive_target(tmp_path: Path, monkeypatch) -> None:
+    url_map = {target_key: None for target_key in download_stackops_offline_installer.KNOWN_TARGETS}
+    url_map["linux-x64"] = "https://drive.google.com/file/d/example/view"
+    captured: dict[str, object] = {}
+
+    def fake_download_and_extract(*, url: str, output_dir: Path) -> None:
+        captured["url"] = url
+        captured["output_dir"] = output_dir
+
+    monkeypatch.setattr(download_stackops_offline_installer, "_load_url_map", lambda: url_map)
+    monkeypatch.setattr(download_stackops_offline_installer, "_download_and_extract", fake_download_and_extract)
+
+    output_dir = tmp_path / "installer"
+
+    resolved_output_dir = download_stackops_offline_installer.download_installer(
+        target_key="linux-x64",
+        output_dir=output_dir,
+    )
+
+    assert resolved_output_dir == output_dir.resolve()
+    assert captured == {
+        "url": "https://drive.google.com/file/d/example/view",
+        "output_dir": output_dir.resolve(),
+    }

stackops-26.6/src/manual/test_stackops_skill_refs.py

@@ -0,0 +1,74 @@
+from datetime import date
+
+from typer.testing import CliRunner
+
+from stackops.scripts.python.helpers.helpers_devops import cli_self_assets, stackops_skill_refs
+
+
+SAMPLE_GRAPH = {
+    "root": {
+        "kind": "root",
+        "name": "stackops",
+        "source": {"file": "src/stackops/scripts/python/stackops_entry.py"},
+        "children": [
+            {
+                "kind": "group",
+                "name": "devops",
+                "fullPath": "devops",
+                "source": {
+                    "file": "src/stackops/scripts/python/stackops_entry.py",
+                    "dispatches_to": "stackops.scripts.python.devops.get_app",
+                },
+                "aliases": [{"name": "d", "hidden": True}],
+                "children": [
+                    {
+                        "kind": "command",
+                        "name": "install",
+                        "fullPath": "devops install",
+                        "source": {"file": "src/stackops/scripts/python/devops.py", "callable": "install"},
+                    }
+                ],
+            },
+            {
+                "kind": "group",
+                "name": "type-fix",
+                "fullPath": "utils pyproject type-fix",
+                "source": {
+                    "file": "src/stackops/scripts/python/helpers/helpers_utils/pyproject_utils_app.py",
+                    "dispatches_to": "stackops.scripts.python.helpers.helpers_utils.type_fix.get_app",
+                },
+                "children": [],
+            },
+        ],
+    }
+}
+
+
+def test_cli_map_uses_canonical_tree_without_alias_nodes() -> None:
+    rendered = stackops_skill_refs.render_cli_map(
+        cli_graph_payload=SAMPLE_GRAPH,
+        project_scripts={"devops": "stackops.scripts.python.devops:main"},
+        generated_on=date(2026, 6, 9),
+    )
+
+    assert "Regenerated from `src/stackops/scripts/python/graph/cli_graph.json` on 2026-06-09." in rendered
+    assert "- `devops` -> `stackops.scripts.python.devops:main`" in rendered
+    assert "├─ devops" in rendered
+    assert "│  └─ install" in rendered
+    assert "└─ type-fix (callback group)" in rendered
+    assert "\n├─ d\n" not in rendered
+
+
+def test_source_map_links_groups_and_leaf_commands() -> None:
+    rendered = stackops_skill_refs.render_source_map(cli_graph_payload=SAMPLE_GRAPH, generated_on=date(2026, 6, 9))
+
+    assert "- `devops` -> `src/stackops/scripts/python/stackops_entry.py` -> `stackops.scripts.python.devops.get_app` via `devops`" in rendered
+    assert "- `devops install` -> `src/stackops/scripts/python/devops.py` -> `install`" in rendered
+    assert "devops self build-assets update-skill-refs" in rendered
+
+
+def test_update_skill_refs_command_is_registered() -> None:
+    result = CliRunner().invoke(cli_self_assets.get_app(), ["--help"])
+
+    assert result.exit_code == 0
+    assert "update-skill-refs" in result.stdout

stackops-26.6/src/manual/test_stackops_versioning.py

@@ -0,0 +1,42 @@
+from datetime import date
+
+import pytest
+
+from stackops.utils.upgrade_packages import (
+    format_stackops_display_version,
+    get_next_stackops_version,
+    parse_stackops_calver,
+)
+
+
+def test_legacy_version_migrates_to_current_calver_month() -> None:
+    assert get_next_stackops_version("8.104", today=date(2026, 6, 9)) == "26.6"
+
+
+def test_same_month_releases_increment_unbounded_release_number() -> None:
+    assert get_next_stackops_version("26.6", today=date(2026, 6, 9)) == "26.6.1"
+    assert get_next_stackops_version("26.6.500", today=date(2026, 6, 9)) == "26.6.501"
+
+
+def test_new_month_release_resets_to_month_base_version() -> None:
+    assert get_next_stackops_version("26.6.500", today=date(2026, 7, 1)) == "26.7"
+    assert get_next_stackops_version("25.12.4", today=date(2026, 1, 1)) == "26.1"
+
+
+def test_future_month_version_is_rejected_to_avoid_downgrade() -> None:
+    with pytest.raises(ValueError, match="later than today's release month"):
+        get_next_stackops_version("26.7", today=date(2026, 6, 9))
+
+
+def test_display_version_keeps_v_prefix_and_canonical_month() -> None:
+    assert format_stackops_display_version("26.6") == "v26.6"
+    assert format_stackops_display_version("26.6.1") == "v26.6.1"
+
+
+def test_calver_parser_accepts_tag_style_and_rejects_invalid_months() -> None:
+    parsed = parse_stackops_calver("v26.6.500")
+    assert parsed is not None
+    assert parsed.year == 26
+    assert parsed.month == 6
+    assert parsed.release == 500
+    assert parse_stackops_calver("8.104") is None

stackops-26.6/src/stackops/cluster/sessions_managers/helpers/__init__.py

@@ -0,0 +1 @@
+"""Session manager helper APIs."""

stackops-26.6/src/stackops/cluster/sessions_managers/tmux/tmux_utils/__init__.py

@@ -0,0 +1 @@
+"""tmux session manager utility APIs."""