s-skillkit 0.2.1__tar.gz → 0.2.2__tar.gz

{s_skillkit-0.2.1 → s_skillkit-0.2.2}/CHANGELOG.md

@@ -4,6 +4,32 @@
 [Keep a Changelog](https://keepachangelog.com/ru/1.1.0/); версионирование —
 [SemVer](https://semver.org/lang/ru/).
 
+## [0.2.2] — 2026-07-21
+
+### Fixed — монорепо-навык (навык в подпапке репозитория)
+
+- **`skill_path` переживает установку**: `_skill_meta.json` теперь хранит
+  подпапку навыка, а `SkillStore.update()` берёт её оттуда, если не передали
+  явно. Раньше в `update` стоял жёсткий `skill_path=None` — обновление
+  материализовало КОРЕНЬ монорепо, и в папку навыка налипали `src/`,
+  `pyproject.toml` и копия самого навыка, а `SKILL.md` оказывался этажом ниже
+  (в таком виде Claude Code навык не видит).
+- **`preserved_paths` читаются из `_skill_meta.toml`** навыка, а не только из
+  захардкоженного списка. Навык может защитить свои данные (папку с БД,
+  кэш) — они переживут обновление; общие дефолты (`_local/`,
+  `browser_profiles/`) при этом сохраняются.
+
+### Added — детект пакетного менеджера (`pkg_manager`)
+
+- `detect_project()` определяет экосистему по маркерам: python (`uv.lock`,
+  `pyproject.toml`, `requirements.txt`), node с КОНКРЕТНЫМ менеджером по
+  lock-файлу (`bun`/`pnpm`/`yarn`/`npm`, при нескольких — по времени
+  изменения), rust, go, ruby, php.
+- `missing_manager_report()` вместо голого «не найдены ни uv, ни pip» отдаёт
+  машиночитаемые факты: тип проекта и маркер, чего не хватает, команда
+  установки под ТЕКУЩУЮ ОС и список реально доступных альтернатив. ИИ-агент
+  может довести установку сам.
+
 ## [0.2.0] — 2026-07-15
 
 ### Added — install-kit (установка навыка «под ключ» со ВСЕМИ зависимостями)

{s_skillkit-0.2.1 → s_skillkit-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s-skillkit
-Version: 0.2.1
+Version: 0.2.2
 Summary: Локальное ядро управления навыками: install из git/локальной папки, junction/symlink-линковка в scope агента, .skillignore-фильтр, build manifest, project-манифест. 0 завязок на сеть/auth — stdlib + tomli-w + pathspec + platformdirs.
 Author: Dmitry
 License: MIT

{s_skillkit-0.2.1 → s_skillkit-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "s-skillkit"
-version = "0.2.1"
+version = "0.2.2"
 description = "Локальное ядро управления навыками: install из git/локальной папки, junction/symlink-линковка в scope агента, .skillignore-фильтр, build manifest, project-манифест. 0 завязок на сеть/auth — stdlib + tomli-w + pathspec + platformdirs."
 readme = "README.md"
 license = { text = "MIT" }

{s_skillkit-0.2.1 → s_skillkit-0.2.2}/skillkit/__init__.py

@@ -97,7 +97,7 @@ from skillkit.targets import (
     get_target,
 )
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 
 __all__ = [
     "__version__",

{s_skillkit-0.2.1 → s_skillkit-0.2.2}/skillkit/deps_installer.py

@@ -38,6 +38,7 @@ from pathlib import Path
 from typing import Any
 
 from skillkit import binary_installer
+from skillkit.pkg_manager import detect_project, missing_manager_report
 
 # kinds внешних бинарей (GitHub Releases) — делегируют binary_installer.
 _BINARY_KINDS = frozenset({"binary", "github-release"})
@@ -182,15 +183,12 @@ def _install_pip(
     elif _pip_available():
         cmd = [python_executable or sys.executable, "-m", "pip", "install", "--upgrade", spec]
     else:
+        # #939: не «не найдены ни uv, ни pip», а факты, по которым агент
+        # доведёт установку сам: тип проекта, чего не хватает, команда под ЭТУ
+        # ОС и чем заменить.
         report["skipped"].append(
-            {
-                **entry,
-                "reason": "не найдены ни uv, ни pip",
-                "instruction": (
-                    f"установите uv (https://docs.astral.sh/uv/) или pip, затем "
-                    f"`pip install {spec}`."
-                ),
-            }
+            {**entry, "reason": "не найдены ни uv, ни pip",
+             **missing_manager_report("uv", spec=spec)}
         )
         return
     rc = _run(cmd)
@@ -208,15 +206,13 @@ def _install_pip(
 def _install_npm(spec: str, report: dict[str, list[dict[str, Any]]]) -> None:
     entry = {"kind": "npm", "spec": spec}
     if _which("npm") is None:
+        # #939: подсказываем менеджер, принятый В ЭТОМ проекте (pnpm/yarn/bun
+        # по lock-файлу), а не абстрактный npm.
+        detection = detect_project(None)
+        wanted = detection.manager if detection.kind == "node" else "npm"
         report["skipped"].append(
-            {
-                **entry,
-                "reason": "npm не найден в PATH",
-                "instruction": (
-                    f"установите Node.js/npm (https://nodejs.org), затем "
-                    f"`npm install -g {spec}`."
-                ),
-            }
+            {**entry, "reason": "npm не найден в PATH",
+             **missing_manager_report(wanted or "npm", spec=spec)}
         )
         return
     rc = _run(["npm", "install", "-g", spec])

{s_skillkit-0.2.1 → s_skillkit-0.2.2}/skillkit/installer/__init__.py

@@ -144,6 +144,11 @@ def set_clone_prefix(prefix: str) -> None:
     _CLONE_PREFIX = prefix
 
 
+def _source_skill_path(source) -> str | None:  # type: ignore[no-untyped-def]
+    """``skill_path`` источника, если он git-овый (иначе None)."""
+    return getattr(source, "skill_path", None)
+
+
 class SkillStore:
     """MVP: install через git clone + write meta. Scope = global | project.
 
@@ -464,6 +469,7 @@ class SkillStore:
                 request.slug, version, request.commit_sha, request.manifest, scope,
                 request.project, self._skill_id_str(request),
                 source=source_label, repo_url=repo_url_meta,
+                skill_path=_source_skill_path(src),
             ),
         )
         return {"is_update": False, "filter_result": filter_result,
@@ -643,6 +649,7 @@ class SkillStore:
             self._build_meta(
                 request.slug, version, request.commit_sha, request.manifest, scope,
                 request.project, skill_id, source=src_label, repo_url=meta_repo,
+                skill_path=_source_skill_path(request.source),
             ),
         )
         return InstallResult(
@@ -688,6 +695,7 @@ class SkillStore:
             self._build_meta(
                 request.slug, version, request.commit_sha, request.manifest, scope,
                 request.project, skill_id, source="hub", repo_url=src.repo_url,
+                skill_path=_source_skill_path(src),
             ),
         )
         return InstallResult(
@@ -742,6 +750,7 @@ class SkillStore:
             self._build_meta(
                 request.slug, version, request.commit_sha, request.manifest, scope,
                 request.project, skill_id, source="hub", repo_url=src.repo_url,
+                skill_path=_source_skill_path(src),
             ),
         )
         return InstallResult(
@@ -771,16 +780,27 @@ class SkillStore:
         skill_id: str | int | None = None,
         local_src: Path | None = None,
         git_ref: str | None = None,
+        skill_path: str | None = None,
     ) -> InstallResult:
-        """Публичный инкрементальный update стор-навыка (требует уже materialized стор)."""
+        """Публичный инкрементальный update стор-навыка (требует уже materialized стор).
+
+        ``skill_path`` (#940): подпапка навыка в монорепо. Если явно не передан —
+        берём из меты установки. Раньше здесь стоял жёсткий ``skill_path=None``:
+        update клонировал репозиторий и материализовывал ЕГО КОРЕНЬ, из-за чего
+        в папку навыка налипали ``src/``, ``pyproject.toml`` и копия самого
+        навыка, а тело навыка оказывалось этажом ниже.
+        """
         scope: Scope = "project" if project is not None else "global"
         dir_name = skill_dir_name(slug, skill_id)
         slug_dir = self._store_path(dir_name)
+        if skill_path is None:
+            existing = read_meta(slug_dir) or {}
+            skill_path = existing.get("skill_path") or None
         request = InstallRequest(
             slug=slug, version=version, commit_sha=commit_sha, manifest=manifest,
             source=source_from_legacy(
                 repo_url=repo_url, local_src=local_src, git_ref=git_ref,
-                skill_path=None,
+                skill_path=skill_path,
             ),
             project=project, skill_id=skill_id,
         )
@@ -899,6 +919,7 @@ class SkillStore:
         skill_id: str | None = None,
         source: Source = "hub",
         repo_url: str | None = None,
+        skill_path: str | None = None,
     ) -> dict[str, Any]:
         return {
             "slug": slug,
@@ -911,6 +932,10 @@ class SkillStore:
             "project": str(project) if project else None,
             "source": source,  # "hub" | "local-path" | "git-url"
             "repo_url": repo_url,  # origin для git-url; None у hub/local
+            # #940: подпапка навыка в монорепо. Без неё update не знал, ЧТО
+            # материализовать, брал корень репозитория и натаскивал в папку
+            # навыка src/, pyproject.toml и копию самого навыка.
+            "skill_path": skill_path,
         }
 
 

{s_skillkit-0.2.1 → s_skillkit-0.2.2}/skillkit/manifest.py

@@ -161,6 +161,25 @@ def git_commit_sha(skill_dir: Path) -> str | None:
         return None
 
 
+# Пути, которые НИКОГДА не сносим при обновлении навыка: локальные данные
+# пользователя. Манифест навыка может добавить свои — но не убрать эти.
+_DEFAULT_PRESERVED = ("_local/", "browser_profiles/")
+
+
+def _preserved_paths(meta_toml: dict) -> list[str]:
+    """Дефолты + ``preserved_paths`` из ``_skill_meta.toml`` навыка.
+
+    Раньше список был ЗАХАРДКОЖЕН, и навык не мог защитить свои данные
+    (например, папку с БД): при update она сносилась как «лишний файл».
+    """
+    out = list(_DEFAULT_PRESERVED)
+    for raw in meta_toml.get("preserved_paths") or []:
+        item = str(raw).strip()
+        if item and item not in out:
+            out.append(item)
+    return out
+
+
 def build_manifest(skill_dir: Path, *, version: str) -> BuiltManifest:
     if not skill_dir.is_dir():
         raise FileNotFoundError(f"Skill папка не найдена: {skill_dir}")
@@ -265,7 +284,7 @@ def build_manifest(skill_dir: Path, *, version: str) -> BuiltManifest:
         tags=tags_list,
         files=sorted(files, key=lambda f: f["path"]),
         dependencies=deps,
-        preserved_paths=["_local/", "browser_profiles/"],
+        preserved_paths=_preserved_paths(meta_toml),
         kind=kind,
         cli=cli_tools,
         mcp=mcp_servers,

s_skillkit-0.2.2/skillkit/pkg_manager.py

@@ -0,0 +1,190 @@
+"""Детект пакетного менеджера проекта и внятная подсказка, когда его нет.
+
+Зачем (#939): у навыка-инструмента бывают ``runtime_dependencies``. Если нужного
+менеджера в системе нет, пользователь раньше получал навык без работающего CLI и
+голое «не найдены ни uv, ни pip» — без ответа на вопросы «а что у меня за
+проект», «что именно поставить» и «какой командой». Для ИИ-агента, который
+доводит установку до конца сам, этого мало: ему нужен машиночитаемый набор
+фактов, а не строка для человека.
+
+Модуль ничего не устанавливает и никогда не бросает — только отвечает на два
+вопроса: «какой менеджер тут уместен» и «как его получить на этой ОС».
+"""
+from __future__ import annotations
+
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+__all__ = [
+    "ProjectDetection",
+    "detect_project",
+    "manager_hint",
+    "missing_manager_report",
+]
+
+# Маркеры экосистем. Порядок важен только внутри node (см. _NODE_LOCKS).
+_PY_MARKERS = ("pyproject.toml", "requirements.txt", "setup.py", "Pipfile")
+_NODE_LOCKS = (
+    ("bun.lockb", "bun"),
+    ("pnpm-lock.yaml", "pnpm"),
+    ("yarn.lock", "yarn"),
+    ("package-lock.json", "npm"),
+)
+
+# Как поставить сам менеджер — по ОС. Значение: {платформа: команда}.
+# `default` — универсальный способ (официальный установщик проекта).
+_MANAGER_INSTALL: dict[str, dict[str, str]] = {
+    "uv": {
+        "win32": "powershell -c \"irm https://astral.sh/uv/install.ps1 | iex\"",
+        "darwin": "brew install uv",
+        "default": "curl -LsSf https://astral.sh/uv/install.sh | sh",
+    },
+    "pip": {
+        "default": f"{Path(sys.executable).name} -m ensurepip --upgrade",
+    },
+    "pipx": {
+        "win32": "py -m pip install --user pipx",
+        "darwin": "brew install pipx",
+        "default": "python3 -m pip install --user pipx",
+    },
+    "npm": {
+        "win32": "winget install OpenJS.NodeJS",
+        "darwin": "brew install node",
+        "default": "curl -fsSL https://fnm.vercel.app/install | bash  # либо пакет node вашей ОС",
+    },
+    "pnpm": {"default": "npm install -g pnpm"},
+    "yarn": {"default": "npm install -g yarn"},
+    "bun": {
+        "win32": "powershell -c \"irm bun.sh/install.ps1 | iex\"",
+        "default": "curl -fsSL https://bun.sh/install | bash",
+    },
+    "cargo": {
+        "win32": "winget install Rustlang.Rustup",
+        "default": "curl https://sh.rustup.rs -sSf | sh",
+    },
+    "go": {
+        "win32": "winget install GoLang.Go",
+        "darwin": "brew install go",
+        "default": "см. https://go.dev/doc/install",
+    },
+    "bundler": {"default": "gem install bundler"},
+    "composer": {"default": "см. https://getcomposer.org/download/"},
+}
+
+# Чем можно заменить отсутствующий менеджер (в порядке предпочтения).
+_ALTERNATIVES: dict[str, tuple[str, ...]] = {
+    "uv": ("pip", "pipx"),
+    "pip": ("uv", "pipx"),
+    "pipx": ("uv", "pip"),
+    "pnpm": ("npm", "yarn", "bun"),
+    "yarn": ("npm", "pnpm"),
+    "bun": ("npm", "pnpm"),
+    "npm": ("pnpm", "yarn", "bun"),
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ProjectDetection:
+    """Что за проект в папке и каким менеджером его обслуживать.
+
+    ``kind`` — экосистема (``python``/``node``/``rust``/``go``/``ruby``/``php``/
+    ``unknown``); ``manager`` — конкретный менеджер (для node выводится из
+    lock-файла); ``marker`` — файл, по которому сделан вывод.
+    """
+
+    kind: str
+    manager: str | None
+    marker: str | None
+
+    @property
+    def manager_available(self) -> bool:
+        return bool(self.manager) and shutil.which(self.manager or "") is not None
+
+
+def _newest(paths: list[Path]) -> Path:
+    """Самый свежий файл (несколько lock-файлов ⇒ верим последнему изменённому)."""
+    return max(paths, key=lambda p: p.stat().st_mtime)
+
+
+def detect_project(root: Path | str | None = None) -> ProjectDetection:
+    """Определить экосистему проекта по файлам-маркерам. Никогда не бросает."""
+    try:
+        base = Path(root or Path.cwd())
+        if not base.is_dir():
+            return ProjectDetection("unknown", None, None)
+
+        # node: менеджер определяется lock-файлом; при нескольких — по mtime.
+        present_locks = [
+            (base / name, mgr) for name, mgr in _NODE_LOCKS if (base / name).exists()
+        ]
+        if present_locks:
+            newest = _newest([p for p, _ in present_locks])
+            manager = next(m for p, m in present_locks if p == newest)
+            return ProjectDetection("node", manager, newest.name)
+        if (base / "package.json").exists():
+            return ProjectDetection("node", "npm", "package.json")
+
+        # python: uv.lock ⇒ проект уже живёт на uv.
+        if (base / "uv.lock").exists():
+            return ProjectDetection("python", "uv", "uv.lock")
+        for marker in _PY_MARKERS:
+            if (base / marker).exists():
+                return ProjectDetection("python", "uv", marker)
+
+        for marker, kind, manager in (
+            ("Cargo.toml", "rust", "cargo"),
+            ("go.mod", "go", "go"),
+            ("Gemfile", "ruby", "bundler"),
+            ("composer.json", "php", "composer"),
+        ):
+            if (base / marker).exists():
+                return ProjectDetection(kind, manager, marker)
+    except OSError:
+        pass
+    return ProjectDetection("unknown", None, None)
+
+
+def manager_hint(manager: str) -> str:
+    """Команда установки менеджера под ТЕКУЩУЮ ОС (или ссылка на инструкцию)."""
+    table = _MANAGER_INSTALL.get(manager)
+    if not table:
+        return f"установите «{manager}» способом, принятым в вашей ОС"
+    return table.get(sys.platform) or table["default"]
+
+
+def missing_manager_report(
+    manager: str,
+    *,
+    spec: str,
+    project_root: Path | str | None = None,
+) -> dict[str, object]:
+    """Машиночитаемое объяснение «менеджера нет» — для ИИ-агента и для человека.
+
+    Возвращает факты, которых раньше не хватало: что за проект вокруг, какого
+    менеджера недостаёт, чем его поставить ИМЕННО на этой ОС и чем заменить.
+    """
+    detection = detect_project(project_root)
+    alternatives = [
+        alt for alt in _ALTERNATIVES.get(manager, ()) if shutil.which(alt) is not None
+    ]
+    return {
+        "missing_manager": manager,
+        "project_kind": detection.kind,
+        "project_marker": detection.marker,
+        "platform": sys.platform,
+        "install_manager_cmd": manager_hint(manager),
+        "available_alternatives": alternatives,
+        "instruction": (
+            f"Зависимость «{spec}» не установлена: нет менеджера «{manager}». "
+            f"Проект определён как {detection.kind}"
+            + (f" (по {detection.marker})" if detection.marker else "")
+            + f". Поставьте менеджер: {manager_hint(manager)}"
+            + (
+                f"; либо используйте уже установленный: {', '.join(alternatives)}."
+                if alternatives
+                else "."
+            )
+        ),
+    }

{s_skillkit-0.2.1 → s_skillkit-0.2.2}/tests/test_manifest.py

@@ -213,3 +213,58 @@ def test_build_manifest_onboarding_absent_is_empty(tmp_path: Path) -> None:
     d = _skill(tmp_path)
     m = build_manifest(d, version="1.0.0")
     assert m.onboarding == {}
+
+
+# ── #940: preserved_paths берутся из манифеста навыка, а не из хардкода ──────
+
+
+def _skill_with_meta(tmp_path, meta_toml: str):
+    """Папка навыка с SKILL.md и заданным _skill_meta.toml."""
+    d = tmp_path / "skill"
+    d.mkdir(parents=True, exist_ok=True)
+    (d / "SKILL.md").write_text(
+        "---\nname: demo\ndescription: d\nversion: 1.0.0\n---\nbody\n",
+        encoding="utf-8",
+    )
+    (d / "_skill_meta.toml").write_text(meta_toml, encoding="utf-8")
+    return d
+
+
+def test_preserved_paths_include_manifest_entries(tmp_path) -> None:
+    """Навык объявил свою папку с данными — она обязана пережить update.
+
+    Раньше список был захардкожен (`_local/`, `browser_profiles/`), и всё
+    остальное сносилось как «лишние файлы» — включая пользовательскую БД.
+    """
+    from skillkit.manifest import build_manifest
+
+    skill = _skill_with_meta(
+        tmp_path,
+        'description = "d"\nversion = "1.0.0"\npreserved_paths = ["data/", "cache/"]\n',
+    )
+    built = build_manifest(skill, version="1.0.0")
+
+    assert "data/" in built.preserved_paths
+    assert "cache/" in built.preserved_paths
+    # Дефолты не потеряны: навык может добавить свои пути, но не убрать общие.
+    assert "_local/" in built.preserved_paths
+    assert "browser_profiles/" in built.preserved_paths
+
+
+def test_preserved_paths_default_when_manifest_silent(tmp_path) -> None:
+    from skillkit.manifest import build_manifest
+
+    skill = _skill_with_meta(tmp_path, 'description = "d"\nversion = "1.0.0"\n')
+    built = build_manifest(skill, version="1.0.0")
+    assert list(built.preserved_paths) == ["_local/", "browser_profiles/"]
+
+
+def test_preserved_paths_no_duplicates(tmp_path) -> None:
+    from skillkit.manifest import build_manifest
+
+    skill = _skill_with_meta(
+        tmp_path,
+        'description = "d"\nversion = "1.0.0"\npreserved_paths = ["_local/", "data/"]\n',
+    )
+    built = build_manifest(skill, version="1.0.0")
+    assert built.preserved_paths.count("_local/") == 1

s_skillkit-0.2.2/tests/test_pkg_manager.py

@@ -0,0 +1,117 @@
+"""#939: детект пакетного менеджера проекта + внятный ответ, когда его нет.
+
+Раньше при отсутствии менеджера пользователь получал навык без работающего CLI
+и строку «не найдены ни uv, ни pip». ИИ-агенту, который доводит установку сам,
+этого мало: нужен машиночитаемый набор фактов — что за проект, чего не хватает,
+какой командой поставить ИМЕННО на этой ОС и чем заменить.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from skillkit.pkg_manager import (
+    detect_project,
+    manager_hint,
+    missing_manager_report,
+)
+
+
+def _touch(root: Path, *names: str) -> None:
+    for n in names:
+        p = root / n
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text("x", encoding="utf-8")
+
+
+class TestDetectProject:
+    def test_python_by_uv_lock(self, tmp_path: Path) -> None:
+        _touch(tmp_path, "pyproject.toml", "uv.lock")
+        d = detect_project(tmp_path)
+        assert (d.kind, d.manager, d.marker) == ("python", "uv", "uv.lock")
+
+    def test_python_by_requirements(self, tmp_path: Path) -> None:
+        _touch(tmp_path, "requirements.txt")
+        assert detect_project(tmp_path).kind == "python"
+
+    def test_node_manager_from_lock_file(self, tmp_path: Path) -> None:
+        """Менеджер node определяется КОНКРЕТНЫМ lock-файлом, а не «просто npm»."""
+        _touch(tmp_path, "package.json", "pnpm-lock.yaml")
+        d = detect_project(tmp_path)
+        assert (d.kind, d.manager) == ("node", "pnpm")
+
+    def test_node_without_lock_defaults_to_npm(self, tmp_path: Path) -> None:
+        _touch(tmp_path, "package.json")
+        assert detect_project(tmp_path).manager == "npm"
+
+    def test_several_locks_newest_wins(self, tmp_path: Path) -> None:
+        """Два lock-файла (переезжали между менеджерами) → верим свежему."""
+        import os
+        import time
+
+        _touch(tmp_path, "package.json", "package-lock.json")
+        time.sleep(0.01)
+        _touch(tmp_path, "yarn.lock")
+        os.utime(tmp_path / "yarn.lock", (time.time() + 10, time.time() + 10))
+        assert detect_project(tmp_path).manager == "yarn"
+
+    def test_rust_go_ruby_php(self, tmp_path: Path) -> None:
+        for marker, kind, manager in (
+            ("Cargo.toml", "rust", "cargo"),
+            ("go.mod", "go", "go"),
+            ("Gemfile", "ruby", "bundler"),
+            ("composer.json", "php", "composer"),
+        ):
+            d_root = tmp_path / kind
+            d_root.mkdir()
+            _touch(d_root, marker)
+            d = detect_project(d_root)
+            assert (d.kind, d.manager) == (kind, manager)
+
+    def test_empty_dir_is_unknown(self, tmp_path: Path) -> None:
+        d = detect_project(tmp_path)
+        assert d.kind == "unknown" and d.manager is None
+
+    def test_missing_dir_does_not_raise(self, tmp_path: Path) -> None:
+        assert detect_project(tmp_path / "нет-такой").kind == "unknown"
+
+
+class TestManagerHint:
+    def test_hint_is_os_specific(self) -> None:
+        hint = manager_hint("uv")
+        assert hint
+        if sys.platform == "win32":
+            assert "powershell" in hint.lower()
+        elif sys.platform == "darwin":
+            assert "brew" in hint
+        else:
+            assert "astral.sh" in hint
+
+    def test_unknown_manager_still_answers(self) -> None:
+        assert "выдуманный" in manager_hint("выдуманный")
+
+
+class TestMissingManagerReport:
+    def test_report_carries_facts_for_agent(self, tmp_path: Path) -> None:
+        _touch(tmp_path, "pyproject.toml", "uv.lock")
+        rep = missing_manager_report("uv", spec="atlas-pm==0.3.5", project_root=tmp_path)
+
+        assert rep["missing_manager"] == "uv"
+        assert rep["project_kind"] == "python"
+        assert rep["project_marker"] == "uv.lock"
+        assert rep["platform"] == sys.platform
+        assert rep["install_manager_cmd"]
+        # Инструкция человекочитаемая и содержит и спеку, и команду.
+        assert "atlas-pm==0.3.5" in rep["instruction"]
+
+    def test_alternatives_only_real_ones(self, tmp_path: Path, monkeypatch) -> None:
+        """В альтернативы попадает только то, что РЕАЛЬНО есть в системе."""
+        monkeypatch.setattr("skillkit.pkg_manager.shutil.which", lambda name: None)
+        rep = missing_manager_report("uv", spec="pkg", project_root=tmp_path)
+        assert rep["available_alternatives"] == []
+
+    def test_node_project_reported_with_its_manager(self, tmp_path: Path) -> None:
+        _touch(tmp_path, "package.json", "bun.lockb")
+        rep = missing_manager_report("bun", spec="cowsay", project_root=tmp_path)
+        assert rep["project_kind"] == "node"
+        assert "bun" in str(rep["instruction"])

{s_skillkit-0.2.1 → s_skillkit-0.2.2}/tests/test_w268_subdir_skill.py

@@ -109,3 +109,56 @@ def test_no_skill_path_uses_repo_root(tmp_path: Path, monkeypatch) -> None:
     store_dir = tmp_path / "store" / "x"
     assert (store_dir / "SKILL.md").exists()
     assert (store_dir / "a.md").exists()
+
+
+# ── #940: подпапка ПЕРЕЖИВАЕТ установку и применяется при update ────────────
+
+
+def test_meta_remembers_skill_path(tmp_path: Path, monkeypatch) -> None:
+    """Без записи skill_path в мету update не знал, что материализовать."""
+    import json
+
+    monkeypatch.setattr(installer_mod.subprocess, "run", _make_fake_clone(_REPO))
+    store = SkillStore(ClaudeCodeTarget(root=tmp_path / ".claude"), tmp_path / "store")
+    store.materialize(
+        slug="atlas", version="1.0.0", commit_sha="a",
+        repo_url="https://github.com/x/atlas-cli.git",
+        manifest=_manifest(_SKILL_FILES),
+        skill_path="skills/atlas",
+    )
+    meta = json.loads(
+        (tmp_path / "store" / "atlas" / "_skill_meta.json").read_text(encoding="utf-8")
+    )
+    assert meta["skill_path"] == "skills/atlas"
+
+
+def test_update_reuses_stored_skill_path(tmp_path: Path, monkeypatch) -> None:
+    """update без явного skill_path берёт его из меты — и снова кладёт ПОДПАПКУ.
+
+    Регрессия: раньше здесь стоял жёсткий ``skill_path=None``, поэтому update
+    материализовал КОРЕНЬ монорепо — в папку навыка налипали src/, pyproject.toml
+    и копия skills/atlas/, а SKILL.md оказывался этажом ниже.
+    """
+    monkeypatch.setattr(installer_mod.subprocess, "run", _make_fake_clone(_REPO))
+    store = SkillStore(ClaudeCodeTarget(root=tmp_path / ".claude"), tmp_path / "store")
+    store.materialize(
+        slug="atlas", version="1.0.0", commit_sha="a",
+        repo_url="https://github.com/x/atlas-cli.git",
+        manifest=_manifest(_SKILL_FILES),
+        skill_path="skills/atlas",
+    )
+
+    bumped = dict(_REPO)
+    bumped["skills/atlas/SKILL.md"] = "---\nname: atlas\nversion: 1.1.0\n---\n# v2"
+    monkeypatch.setattr(installer_mod.subprocess, "run", _make_fake_clone(bumped))
+    store.update(
+        slug="atlas", version="1.1.0", commit_sha="b",
+        repo_url="https://github.com/x/atlas-cli.git",
+        manifest=_manifest({**_SKILL_FILES, "SKILL.md": bumped["skills/atlas/SKILL.md"]}),
+    )
+
+    store_dir = tmp_path / "store" / "atlas"
+    assert (store_dir / "SKILL.md").read_text(encoding="utf-8").endswith("# v2")
+    assert not (store_dir / "pyproject.toml").exists(), "корень монорепо налип"
+    assert not (store_dir / "src").exists()
+    assert not (store_dir / "skills").exists(), "копия навыка внутри навыка"