apm-cli 0.23.0__tar.gz → 0.23.1__tar.gz

{apm_cli-0.23.0/src/apm_cli.egg-info → apm_cli-0.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apm-cli
-Version: 0.23.0
+Version: 0.23.1
 Summary: MCP configuration tool
 Author-email: Daniel Meppiel <user@example.com>
 License: MIT License

{apm_cli-0.23.0 → apm_cli-0.23.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apm-cli"
-version = "0.23.0"
+version = "0.23.1"
 description = "MCP configuration tool"
 readme = "README.md"
 requires-python = ">=3.10"

{apm_cli-0.23.0 → apm_cli-0.23.1}/src/apm_cli/commands/install.py

@@ -47,8 +47,9 @@ from apm_cli.install.mcp.entry import _build_mcp_entry  # noqa: F401
 from apm_cli.install.mcp.writer import _add_mcp_to_apm_yml  # noqa: F401
 from apm_cli.install.package_resolution import (
     GIT_PARENT_USER_SCOPE_ERROR,
+    apply_cli_skill_pin,
+    cli_skill_subset,
     dependency_reference_to_yaml_entry,
-    normalize_and_merge_skill_subset,
     persist_dependency_list_if_changed,
     resolve_parsed_dependency_reference,
     update_existing_dependency_entry_if_needed,
@@ -329,6 +330,7 @@ def _resolve_package_references(
     scope=None,
     allow_insecure=False,
     skill_subset=None,
+    skill_subset_from_cli=False,
     default_registry=None,
 ):
     """Validate, canonicalize, and resolve package references.
@@ -453,16 +455,15 @@ def _resolve_package_references(
             )
             canonical = dep_ref.to_canonical()
             identity = dep_ref.get_identity()
-            # Attach --skill filter so to_apm_yml_entry() emits the dict form.
-            # Merges with existing skills: list so repeated --skill
-            # invocations are additive (issue #1771).
-            if skill_subset:
-                dep_ref.skill_subset = normalize_and_merge_skill_subset(
-                    skill_subset,
-                    current_deps,
-                    identity,
-                    dependency_reference_cls=DependencyReference,
-                )
+            apply_cli_skill_pin(
+                dep_ref,
+                skill_subset,
+                skill_subset_from_cli,
+                current_deps,
+                _apm_yml_entries,
+                dependency_reference_cls=DependencyReference,
+                logger=logger,
+            )
             if marketplace_dep_ref is not None or direct_virtual_resolved:
                 _apm_yml_entries[canonical] = dependency_reference_to_yaml_entry(dep_ref)
         except ValueError as e:
@@ -633,6 +634,7 @@ def _validate_and_add_packages_to_apm_yml(
     scope=None,
     allow_insecure=False,
     skill_subset=None,
+    skill_subset_from_cli=False,
 ):
     """Validate packages exist and can be accessed, then add to apm.yml dependencies section.
 
@@ -701,6 +703,7 @@ def _validate_and_add_packages_to_apm_yml(
         scope=scope,
         allow_insecure=allow_insecure,
         skill_subset=skill_subset,
+        skill_subset_from_cli=skill_subset_from_cli,
         default_registry=_default_registry_for_cli,
     )
 
@@ -1048,7 +1051,7 @@ def _handle_mcp_install(
     "skill_names",
     multiple=True,
     metavar="NAME",
-    help="Install only named skill(s) from a SKILL_BUNDLE. Repeatable. Persisted in apm.yml and apm.lock so bare 'apm install' is deterministic. Use --skill '*' to reset to all skills.",
+    help="Install only named skill(s) from a SKILL_BUNDLE. Repeatable. Persisted in apm.yml and apm.lock so bare 'apm install' is deterministic. Additive across installs: a later --skill X adds X to the existing pin (union) rather than replacing it. Use --skill '*' (quote the asterisk in your shell) to reset to all skills; to drop a single skill, edit the skills: list in apm.yml then re-run apm install.",
 )
 @click.option(
     "--no-policy",
@@ -1384,12 +1387,9 @@ def install(  # noqa: PLR0913
         )
 
         # Normalize --skill: '*' means all (same as absent). Reject with --mcp.
-        _skill_subset = None
-        if skill_names:
-            if mcp_name is not None:
-                raise click.UsageError("--skill cannot be combined with --mcp.")
-            if not any(s == "*" for s in skill_names):
-                _skill_subset = builtins.tuple(skill_names)
+        if skill_names and mcp_name is not None:
+            raise click.UsageError("--skill cannot be combined with --mcp.")
+        _skill_subset = cli_skill_subset(skill_names)
 
         if mcp_name is not None:
             _handle_mcp_install(
@@ -1517,6 +1517,7 @@ def install(  # noqa: PLR0913
                 scope=scope,
                 allow_insecure=allow_insecure,
                 skill_subset=_skill_subset,
+                skill_subset_from_cli=bool(skill_names),
             )
             # Short-circuit: all packages failed validation -- nothing to install
             if outcome.all_failed:

{apm_cli-0.23.0 → apm_cli-0.23.1}/src/apm_cli/install/package_resolution.py

@@ -180,6 +180,87 @@ def normalize_and_merge_skill_subset(
     return sorted(seen)
 
 
+def effective_deploy_skill_subset(
+    *,
+    skill_subset_from_cli: bool,
+    cli_subset: builtins.tuple[str, ...] | builtins.list[str] | None,
+    persisted_subset: builtins.tuple[str, ...] | builtins.list[str] | None,
+) -> builtins.tuple[str, ...] | None:
+    """Resolve the skill subset to *deploy* for a SKILL_BUNDLE.
+
+    ``--skill`` is additive (issue #1786): a targeted ``--skill B`` install must
+    land on top of skills already pinned for the bundle instead of erasing them.
+    The deployment therefore uses the union of the persisted manifest subset and
+    the current CLI ``--skill`` values -- not the raw CLI subset alone.
+
+    ``--skill '*'`` (signalled by ``skill_subset_from_cli`` True with an empty
+    ``cli_subset``) resets the bundle to its full set, so this returns ``None``
+    meaning "deploy all skills".
+
+    Returns a sorted, deduplicated tuple, or ``None`` for "deploy all".
+    """
+    if skill_subset_from_cli and not cli_subset:
+        return None  # --skill '*' -> full bundle
+    merged: builtins.set[str] = builtins.set()
+    if persisted_subset:
+        merged.update(persisted_subset)
+    if cli_subset:
+        merged.update(cli_subset)
+    return builtins.tuple(sorted(merged)) or None
+
+
+def cli_skill_subset(
+    skill_names: builtins.tuple[str, ...],
+) -> builtins.tuple[str, ...] | None:
+    """Resolve raw CLI ``--skill`` names to a subset, or None for absent / ``'*'``.
+
+    ``--skill '*'`` means "all skills" (same as absent); the resolver still
+    learns the flag was present via a separate CLI-origin flag, so this
+    collapses both the absent and ``'*'`` cases to None.
+    """
+    if skill_names and not any(s == "*" for s in skill_names):
+        return builtins.tuple(skill_names)
+    return None
+
+
+def apply_cli_skill_pin(
+    dep_ref: Any,
+    cli_subset: builtins.tuple[str, ...] | None,
+    skill_subset_from_cli: bool,
+    current_deps: builtins.list,
+    apm_yml_entries: dict,
+    *,
+    dependency_reference_cls: Any,
+    logger: Any | None = None,
+) -> None:
+    """Attach, merge, or reset a CLI ``--skill`` pin on ``dep_ref`` in place.
+
+    With an explicit ``cli_subset``, merge it additively with any persisted
+    ``skills:`` so repeated ``--skill`` invocations union rather than replace
+    (issue #1771). With ``--skill '*'`` (``skill_subset_from_cli`` True and an
+    empty ``cli_subset``), reset the pin back to the full bundle and record the
+    refreshed plain-string ``apm.yml`` entry under the reference's canonical key
+    so manifest and on-disk state agree on the whole bundle (issue #1786 reset).
+    """
+    identity = dep_ref.get_identity()
+    if cli_subset:
+        dep_ref.skill_subset = normalize_and_merge_skill_subset(
+            cli_subset,
+            current_deps,
+            identity,
+            dependency_reference_cls=dependency_reference_cls,
+        )
+        return
+    if skill_subset_from_cli:
+        dep_ref.skill_subset = None
+        apm_yml_entries[dep_ref.to_canonical()] = dep_ref.to_apm_yml_entry()
+        if logger:
+            logger.verbose_detail(
+                f"    [i] {identity}: skill pin reset to full bundle "
+                "(--skill '*'); a later bare 'apm install' deploys all skills"
+            )
+
+
 def manifest_has_different_entry_for_identity(
     current_deps: builtins.list,
     identity: str,

{apm_cli-0.23.0 → apm_cli-0.23.1}/src/apm_cli/install/phases/lockfile.py

@@ -19,6 +19,7 @@ import copy
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from apm_cli.install.package_resolution import effective_deploy_skill_subset
 from apm_cli.utils.content_hash import compute_file_hash
 
 if TYPE_CHECKING:
@@ -228,18 +229,31 @@ class LockfileBuilder:
                 lockfile.dependencies[dep_key].exec_status = status
 
     def _attach_skill_subset_override(self, lockfile: LockFile) -> None:
-        """Apply CLI --skill override to lockfile skill_bundle entries.
+        """Union the CLI ``--skill`` values into lockfile skill_bundle entries.
 
-        When the user runs `apm install bundle --skill foo`, the CLI
-        skill_subset takes precedence over the per-entry skill_subset
-        from the manifest for this invocation's lockfile.
+        ``--skill`` is additive (issue #1786): a targeted ``apm install bundle
+        --skill foo`` must record the UNION of the previously pinned skills and
+        ``foo`` -- not replace the persisted subset with the raw CLI value. The
+        per-entry manifest subset already flows into ``locked_dep.skill_subset``;
+        here we fold in the current CLI values so the lockfile matches what was
+        deployed.
+
+        ``--skill '*'`` (empty ``ctx.skill_subset``) is a no-op here -- the
+        manifest reset already flowed the full-bundle (empty) subset through.
         """
         if not self.ctx.skill_subset:
-            return  # No CLI override; dep_ref.skill_subset already flows through
-        effective = sorted(set(self.ctx.skill_subset))
+            return  # bare install or --skill '*'; manifest value already flows through
         for dep_key, locked_dep in lockfile.dependencies.items():  # noqa: B007
             if locked_dep.package_type == "skill_bundle":
-                locked_dep.skill_subset = effective
+                merged = effective_deploy_skill_subset(
+                    skill_subset_from_cli=self.ctx.skill_subset_from_cli,
+                    cli_subset=self.ctx.skill_subset,
+                    persisted_subset=locked_dep.skill_subset,
+                )
+                # merged is never None here: the guard above returns for
+                # --skill '*' (empty ctx.skill_subset), so a real named
+                # subset always survives the union.
+                locked_dep.skill_subset = list(merged) if merged else []
 
     def _attach_content_hashes(self, lockfile: LockFile) -> None:
         for dep_key, locked_dep in lockfile.dependencies.items():

{apm_cli-0.23.0 → apm_cli-0.23.1}/src/apm_cli/install/template.py

@@ -14,6 +14,7 @@ This is the Template Method companion to the Strategy pattern in
 from __future__ import annotations
 
 from apm_cli.install.helpers.security_scan import _pre_deploy_security_scan
+from apm_cli.install.package_resolution import effective_deploy_skill_subset
 from apm_cli.install.services import IntegratorBundle, integrate_package_primitives
 from apm_cli.install.sources import DependencySource, Materialization
 
@@ -128,6 +129,26 @@ def _integrate_materialization(
             ctx.package_deployed_files[dep_key] = []
             return deltas
 
+        # Per-package effective subset: ``--skill`` is additive (issue
+        # #1786), so deploy the UNION of the persisted apm.yml ``skills:``
+        # and the current CLI ``--skill`` values -- a targeted ``--skill``
+        # install lands on top of previously pinned skills instead of
+        # erasing them. ``--skill '*'`` resets to the full bundle (None).
+        effective_skill_subset = effective_deploy_skill_subset(
+            skill_subset_from_cli=ctx.skill_subset_from_cli,
+            cli_subset=ctx.skill_subset,
+            persisted_subset=dep_ref.skill_subset,
+        )
+        # When the additive union deploys more skills than the user named on
+        # this invocation, name the retained pins so the deployed set is not
+        # a silent surprise (verbose only -- the count already renders).
+        if logger and ctx.skill_subset and effective_skill_subset:
+            retained = sorted(set(effective_skill_subset) - set(ctx.skill_subset))
+            if retained:
+                logger.verbose_detail(
+                    f"    [i] {dep_key}: retaining previously pinned "
+                    f"skill(s): {', '.join(retained)}"
+                )
         int_result = integrate_package_primitives(
             m.package_info,
             ctx.project_root,
@@ -147,16 +168,7 @@ def _integrate_materialization(
             package_name=dep_key,
             logger=logger,
             scope=ctx.scope,
-            # Per-package effective subset: CLI --skill overrides per-entry
-            # apm.yml skills:. When CLI is absent (bare reinstall), fall back
-            # to the dep_ref's persisted skill_subset.
-            # When CLI explicitly provided (even --skill '*'), use ctx value
-            # (which is None for '*' = install all).
-            skill_subset=(
-                ctx.skill_subset
-                if ctx.skill_subset_from_cli
-                else (tuple(dep_ref.skill_subset) if dep_ref.skill_subset else None)
-            ),
+            skill_subset=effective_skill_subset,
             dep_target_subset=dep_ref.target_subset,
             ctx=ctx,
             allow_executables=_effective_allow(ctx),

{apm_cli-0.23.0 → apm_cli-0.23.1}/src/apm_cli/utils/content_hash.py

@@ -4,6 +4,7 @@ import hashlib
 from pathlib import Path
 
 from apm_cli.install.cache_pin import MARKER_FILENAME as _APM_PIN_MARKER
+from apm_cli.utils.atomic_io import normalize_crlf_to_lf
 
 # Directories excluded from hashing (not relevant to package content)
 _EXCLUDED_DIRS = {".git", "__pycache__"}
@@ -28,6 +29,14 @@ def compute_package_hash(package_path: Path) -> str:
     making it independent of filesystem ordering and metadata (timestamps,
     permissions).
 
+    Note: this whole-tree hash intentionally hashes raw file bytes, unlike
+    the per-file :func:`compute_file_hash` which normalizes CRLF->LF for
+    text (apm#1952). The package tree is hashed at the git-checkout
+    boundary where content is already platform-canonical, and the path is
+    bound into the digest, so cross-platform line-ending identity is
+    unnecessary here. Do not unify the two without re-checking that
+    invariant.
+
     Args:
         package_path: Root directory of the installed package.
 
@@ -70,14 +79,58 @@ def compute_package_hash(package_path: Path) -> str:
     return f"sha256:{hasher.hexdigest()}"
 
 
+def _canonical_hash_bytes(raw: bytes) -> bytes:
+    """Return the canonical byte image used for per-file content hashing.
+
+    Text content (UTF-8-decodable and free of NUL bytes) is line-ending
+    normalized CRLF -> LF, with bare CR preserved, so the deployed-file
+    hash is platform-invariant (apm#1952): a file that git materializes
+    as ``\\r\\n`` on Windows and ``\\n`` on POSIX hashes identically.
+    Detection is content-based (not suffix-based) so integrator renames
+    such as ``.md`` -> ``.mdc`` are still normalized.
+
+    Binary content -- anything that is not valid UTF-8, or that contains
+    a NUL byte (e.g. UTF-16, images) -- is hashed raw; normalizing it
+    would be meaningless and could corrupt the integrity witness.
+
+    Preserving bare CR (only ``\\r\\n`` collapses to ``\\n``) keeps the
+    carriage-return smuggling vector hash-visible: solely the benign
+    line-terminator difference is made invisible, never a lone ``\\r``
+    that a terminal or parser could interpret as an overwrite. On line
+    endings this aligns with the drift-replay normalizer
+    (:func:`apm_cli.utils.normalization._normalize_line_endings`), so the
+    ``content-integrity`` audit and the drift-replay audit no longer
+    disagree about whether a CRLF/LF difference is a content change.
+    (Drift-replay additionally strips BOM and build-id markers; this
+    per-file integrity hash deliberately does not -- those remain
+    hash-visible here.)
+    """
+    if b"\x00" in raw:
+        return raw
+    try:
+        text = raw.decode("utf-8")
+    except UnicodeDecodeError:
+        return raw
+    return normalize_crlf_to_lf(text).encode("utf-8")
+
+
 def compute_file_hash(file_path: Path) -> str:
-    """Compute SHA-256 of a single file's contents.
+    """Compute SHA-256 of a single file's content (line-ending-normalized).
 
     Used for per-deployed-file provenance checks before APM deletes a
     file recorded in ``deployed_files``. The path itself is not mixed
     in (unlike :func:`compute_package_hash`) because deployed files may
     be renamed by integrators (e.g. ``.md`` -> ``.mdc`` for Cursor).
 
+    UTF-8 text content is hashed over its CRLF -> LF normalized form
+    (bare CR preserved) so the hash is identical on every platform,
+    regardless of whether git ``core.autocrlf`` materialized the file
+    with ``\\n`` or ``\\r\\n`` (apm#1952). This makes the record side
+    (``apm install``) and the verify side (``apm audit``) symmetric by
+    construction across operating systems. Binary content (non-UTF-8 or
+    containing a NUL byte) is hashed raw. See :func:`_canonical_hash_bytes`
+    for the security rationale.
+
     Args:
         file_path: File to hash.
 
@@ -89,7 +142,7 @@ def compute_file_hash(file_path: Path) -> str:
     if not file_path.is_file() or file_path.is_symlink():
         return _EMPTY_HASH
     hasher = hashlib.sha256()
-    hasher.update(file_path.read_bytes())
+    hasher.update(_canonical_hash_bytes(file_path.read_bytes()))
     return f"sha256:{hasher.hexdigest()}"
 
 

{apm_cli-0.23.0 → apm_cli-0.23.1/src/apm_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apm-cli
-Version: 0.23.0
+Version: 0.23.1
 Summary: MCP configuration tool
 Author-email: Daniel Meppiel <user@example.com>
 License: MIT License