apm-cli 0.8.4__tar.gz → 0.8.6__tar.gz

{apm_cli-0.8.4/src/apm_cli.egg-info → apm_cli-0.8.6}/PKG-INFO

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

{apm_cli-0.8.4 → apm_cli-0.8.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apm-cli"
-version = "0.8.4"
+version = "0.8.6"
 description = "MCP configuration tool"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -71,7 +71,7 @@ warn_return_any = true
 warn_unused_configs = true
 
 [tool.pytest.ini_options]
-addopts = "-m 'not benchmark' -n auto"
+addopts = "-m 'not benchmark'"
 markers = [
     "integration: marks tests as integration tests that may require network access",
     "slow: marks tests as slow running tests",

apm_cli-0.8.6/src/apm_cli/bundle/lockfile_enrichment.py

@@ -0,0 +1,154 @@
+"""Lockfile enrichment for pack-time metadata."""
+
+from datetime import datetime, timezone
+from typing import Dict, List, Tuple
+
+from ..deps.lockfile import LockFile
+
+
+# Authoritative mapping of target names to deployed-file path prefixes.
+_TARGET_PREFIXES = {
+    "copilot": [".github/"],
+    "vscode": [".github/"],
+    "claude": [".claude/"],
+    "cursor": [".cursor/"],
+    "opencode": [".opencode/"],
+    "all": [".github/", ".claude/", ".cursor/", ".opencode/"],
+}
+
+# Cross-target path equivalences for skills/ and agents/ directories.
+# Only these two directory types are semantically identical across targets;
+# commands, instructions, hooks are target-specific and are NOT mapped.
+#
+# .github/ is the canonical interop prefix -- install always creates it, so
+# all non-github targets map FROM .github/.  The copilot target additionally
+# maps FROM .claude/ for the common case of Claude-first projects packing
+# for Copilot.  Cursor/opencode sources are niche; if someone publishes
+# skills exclusively under .cursor/, they must pack with --target cursor.
+_CROSS_TARGET_MAPS: Dict[str, Dict[str, str]] = {
+    "claude": {
+        ".github/skills/": ".claude/skills/",
+        ".github/agents/": ".claude/agents/",
+    },
+    "vscode": {
+        ".claude/skills/": ".github/skills/",
+        ".claude/agents/": ".github/agents/",
+    },
+    "copilot": {
+        ".claude/skills/": ".github/skills/",
+        ".claude/agents/": ".github/agents/",
+    },
+    "cursor": {
+        ".github/skills/": ".cursor/skills/",
+        ".github/agents/": ".cursor/agents/",
+    },
+    "opencode": {
+        ".github/skills/": ".opencode/skills/",
+        ".github/agents/": ".opencode/agents/",
+    },
+}
+
+
+def _filter_files_by_target(
+    deployed_files: List[str], target: str
+) -> Tuple[List[str], Dict[str, str]]:
+    """Filter deployed file paths by target prefix, with cross-target mapping.
+
+    When files are deployed under one target prefix (e.g. ``.github/skills/``)
+    but the pack target is different (e.g. ``claude``), skills and agents are
+    remapped to the equivalent target path.  Commands, instructions, and hooks
+    are NOT remapped -- they are target-specific.
+
+    Returns:
+        A tuple of ``(filtered_files, path_mappings)`` where *path_mappings*
+        maps ``bundle_path -> disk_path`` for any file that was cross-target
+        remapped.  Direct matches have no entry in the dict.
+    """
+    prefixes = _TARGET_PREFIXES.get(target, _TARGET_PREFIXES["all"])
+    direct = [f for f in deployed_files if any(f.startswith(p) for p in prefixes)]
+
+    path_mappings: Dict[str, str] = {}
+    cross_map = _CROSS_TARGET_MAPS.get(target, {})
+    if cross_map:
+        direct_set = set(direct)
+        for f in deployed_files:
+            if f in direct_set:
+                continue
+            for src_prefix, dst_prefix in cross_map.items():
+                if f.startswith(src_prefix):
+                    mapped = dst_prefix + f[len(src_prefix):]
+                    if mapped not in direct_set:
+                        direct.append(mapped)
+                        direct_set.add(mapped)
+                        path_mappings[mapped] = f
+                    break
+
+    return direct, path_mappings
+
+
+def enrich_lockfile_for_pack(
+    lockfile: LockFile,
+    fmt: str,
+    target: str,
+) -> str:
+    """Create an enriched copy of the lockfile YAML with a ``pack:`` section.
+
+    Filters each dependency's ``deployed_files`` to only include paths
+    matching the pack *target*, so the bundle lockfile is consistent with
+    the files actually shipped in the bundle.
+
+    Does NOT mutate the original *lockfile* object  -- serialises a copy and
+    prepends the pack metadata.
+
+    Args:
+        lockfile: The resolved lockfile to enrich.
+        fmt: Bundle format (``"apm"`` or ``"plugin"``).
+        target: Effective target used for packing (e.g. ``"copilot"``, ``"claude"``,
+            ``"all"``).  The internal alias ``"vscode"`` is also accepted.
+
+    Returns:
+        A YAML string with the ``pack:`` block followed by the original
+        lockfile content.
+    """
+    import yaml
+
+    # Build a filtered lockfile YAML: each dep's deployed_files is narrowed
+    # to only the paths matching the pack target (with cross-target mapping).
+    all_mappings: Dict[str, str] = {}
+    data = yaml.safe_load(lockfile.to_yaml())
+    if data and "dependencies" in data:
+        for dep in data["dependencies"]:
+            if "deployed_files" in dep:
+                filtered, mappings = _filter_files_by_target(
+                    dep["deployed_files"], target
+                )
+                dep["deployed_files"] = filtered
+                all_mappings.update(mappings)
+
+    # Build the pack: metadata section (after filtering so we know if mapping
+    # occurred).
+    pack_meta: Dict = {
+        "format": fmt,
+        "target": target,
+        "packed_at": datetime.now(timezone.utc).isoformat(),
+    }
+    if all_mappings:
+        # Record the source prefixes that were remapped so consumers know the
+        # bundle paths differ from the original lockfile.  Use the canonical
+        # prefix keys from _CROSS_TARGET_MAPS rather than reverse-engineering
+        # them from file paths.
+        cross_map = _CROSS_TARGET_MAPS.get(target, {})
+        used_src_prefixes = set()
+        for original in all_mappings.values():
+            for src_prefix in cross_map:
+                if original.startswith(src_prefix):
+                    used_src_prefixes.add(src_prefix)
+                    break
+        pack_meta["mapped_from"] = sorted(used_src_prefixes)
+
+    from ..utils.yaml_io import yaml_to_str
+
+    pack_section = yaml_to_str({"pack": pack_meta})
+
+    lockfile_yaml = yaml_to_str(data)
+    return pack_section + lockfile_yaml

{apm_cli-0.8.4 → apm_cli-0.8.6}/src/apm_cli/bundle/packer.py

@@ -5,12 +5,12 @@ import shutil
 import tarfile
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from ..deps.lockfile import LockFile, get_lockfile_path, migrate_lockfile_if_needed
 from ..models.apm_package import APMPackage
 from ..core.target_detection import detect_target
-from .lockfile_enrichment import enrich_lockfile_for_pack, _TARGET_PREFIXES, _filter_files_by_target
+from .lockfile_enrichment import enrich_lockfile_for_pack, _filter_files_by_target
 
 
 @dataclass
@@ -20,6 +20,8 @@ class PackResult:
     bundle_path: Path
     files: List[str] = field(default_factory=list)
     lockfile_enriched: bool = False
+    mapped_count: int = 0
+    path_mappings: Dict[str, str] = field(default_factory=dict)
 
 
 def pack_bundle(
@@ -38,7 +40,7 @@ def pack_bundle(
         project_root: Root of the project containing ``apm.lock.yaml`` and ``apm.yml``.
         output_dir: Directory where the bundle will be created.
         fmt: Bundle format  -- ``"apm"`` (default) or ``"plugin"``.
-        target: Target filter  -- ``"vscode"``, ``"claude"``, ``"all"``, or *None*
+        target: Target filter  -- ``"copilot"``, ``"claude"``, ``"all"``, or *None*
             (auto-detect from apm.yml / project structure).
         archive: If *True*, produce a ``.tar.gz`` and remove the directory.
         dry_run: If *True*, resolve the file list but write nothing to disk.
@@ -114,7 +116,7 @@ def pack_bundle(
     for dep in lockfile.get_all_dependencies():
         all_deployed.extend(dep.deployed_files)
 
-    filtered_files = _filter_files_by_target(all_deployed, effective_target)
+    filtered_files, path_mappings = _filter_files_by_target(all_deployed, effective_target)
     # Deduplicate while preserving order
     seen = set()
     unique_files: List[str] = []
@@ -133,14 +135,16 @@ def pack_bundle(
             raise ValueError(
                 f"Refusing to pack unsafe path from lockfile: {rel_path!r}"
             )
-        abs_path = project_root / rel_path
+        # For cross-target mapped files, verify the original (on-disk) path
+        disk_path = path_mappings.get(rel_path, rel_path)
+        abs_path = project_root / disk_path
         if not abs_path.resolve().is_relative_to(project_root_resolved):
             raise ValueError(
-                f"Refusing to pack path that escapes project root: {rel_path!r}"
+                f"Refusing to pack path that escapes project root: {disk_path!r}"
             )
         # deployed_files may reference directories (ending with /)
         if not abs_path.exists():
-            missing.append(rel_path)
+            missing.append(disk_path)
     if missing:
         raise ValueError(
             f"The following deployed files are missing on disk  -- "
@@ -155,6 +159,8 @@ def pack_bundle(
             bundle_path=bundle_dir,
             files=unique_files,
             lockfile_enriched=True,
+            mapped_count=len(path_mappings),
+            path_mappings=path_mappings,
         )
 
     # 5b. Scan files for hidden characters before bundling.
@@ -168,7 +174,8 @@ def pack_bundle(
 
     _scan_findings_total = 0
     for rel_path in unique_files:
-        src = project_root / rel_path
+        disk_path = path_mappings.get(rel_path, rel_path)
+        src = project_root / disk_path
         if src.is_symlink():
             continue
         if src.is_dir():
@@ -193,13 +200,21 @@ def pack_bundle(
     # 6. Build output directory
     bundle_dir = output_dir / f"{pkg_name}-{pkg_version}"
     bundle_dir.mkdir(parents=True, exist_ok=True)
+    bundle_dir_resolved = bundle_dir.resolve()
 
     # 7. Copy files preserving directory structure
     for rel_path in unique_files:
-        src = project_root / rel_path
+        # For cross-target mapped files, read from the original disk path
+        disk_path = path_mappings.get(rel_path, rel_path)
+        src = project_root / disk_path
         if src.is_symlink():
             continue  # Never bundle symlinks
         dest = bundle_dir / rel_path
+        # Defense-in-depth: verify mapped destination stays inside the bundle
+        if not dest.resolve().is_relative_to(bundle_dir_resolved):
+            raise ValueError(
+                f"Refusing to write outside bundle directory: {rel_path!r}"
+            )
         if src.is_dir():
             from ..security.gate import ignore_symlinks
             shutil.copytree(src, dest, dirs_exist_ok=True, ignore=ignore_symlinks)
@@ -215,6 +230,8 @@ def pack_bundle(
         bundle_path=bundle_dir,
         files=unique_files,
         lockfile_enriched=True,
+        mapped_count=len(path_mappings),
+        path_mappings=path_mappings,
     )
 
     # 10. Archive if requested

{apm_cli-0.8.4 → apm_cli-0.8.6}/src/apm_cli/bundle/plugin_exporter.py

@@ -285,7 +285,8 @@ def _get_dev_dependency_urls(apm_yml_path: Path) -> Set[Tuple[str, str]]:
     ``github/awesome-copilot``).
     """
     try:
-        data = yaml.safe_load(apm_yml_path.read_text(encoding="utf-8"))
+        from ..utils.yaml_io import load_yaml
+        data = load_yaml(apm_yml_path)
     except (yaml.YAMLError, OSError, ValueError):
         return set()
     if not isinstance(data, dict):

{apm_cli-0.8.4 → apm_cli-0.8.6}/src/apm_cli/bundle/unpacker.py

@@ -22,6 +22,7 @@ class UnpackResult:
     skipped_count: int = 0
     security_warnings: int = 0
     security_critical: int = 0
+    pack_meta: Dict = field(default_factory=dict)
 
 
 def unpack_bundle(
@@ -98,6 +99,18 @@ def unpack_bundle(
             legacy_lockfile_path = source_dir / LEGACY_LOCKFILE_NAME
             if legacy_lockfile_path.exists():
                 lockfile_path = legacy_lockfile_path
+
+        # Extract pack: metadata (written by apm pack) before structured parse
+        pack_meta: Dict = {}
+        try:
+            import yaml
+            raw = yaml.safe_load(lockfile_path.read_text(encoding="utf-8"))
+            if isinstance(raw, dict):
+                val = raw.get("pack", {})
+                pack_meta = val if isinstance(val, dict) else {}
+        except Exception:
+            pass  # non-critical -- proceed without metadata
+
         lockfile = LockFile.read(lockfile_path)
         if lockfile is None:
             if not lockfile_path.exists():
@@ -176,6 +189,7 @@ def unpack_bundle(
                 dependency_files=dep_file_map,
                 security_warnings=security_warnings,
                 security_critical=security_critical,
+                pack_meta=pack_meta,
             )
 
         # 4. Copy target files to output_dir (additive, no deletes)
@@ -219,6 +233,7 @@ def unpack_bundle(
             skipped_count=skipped,
             security_warnings=security_warnings,
             security_critical=security_critical,
+            pack_meta=pack_meta,
         )
     finally:
         # Clean up temp dir if we created one

{apm_cli-0.8.4 → apm_cli-0.8.6}/src/apm_cli/commands/_helpers.py

@@ -331,9 +331,8 @@ def _update_gitignore_for_apm_modules(logger=None):
 def _load_apm_config():
     """Load configuration from apm.yml."""
     if Path(APM_YML_FILENAME).exists():
-        with open(APM_YML_FILENAME, "r") as f:
-            yaml = _lazy_yaml()
-            return yaml.safe_load(f)
+        from ..utils.yaml_io import load_yaml
+        return load_yaml(APM_YML_FILENAME)
     return None
 
 
@@ -440,8 +439,6 @@ def _create_minimal_apm_yml(config, plugin=False):
         config: dict with name, version, description, author keys.
         plugin: if True, include a devDependencies section.
     """
-    yaml = _lazy_yaml()
-
     # Create minimal apm.yml structure
     apm_yml_data = {
         "name": config["name"],
@@ -457,5 +454,5 @@ def _create_minimal_apm_yml(config, plugin=False):
     apm_yml_data["scripts"] = {}
 
     # Write apm.yml
-    with open(APM_YML_FILENAME, "w") as f:
-        yaml.safe_dump(apm_yml_data, f, default_flow_style=False, sort_keys=False)
+    from ..utils.yaml_io import dump_yaml
+    dump_yaml(apm_yml_data, APM_YML_FILENAME)