apm-cli 0.7.5__tar.gz → 0.7.7__tar.gz

{apm_cli-0.7.5/src/apm_cli.egg-info → apm_cli-0.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apm-cli
-Version: 0.7.5
+Version: 0.7.7
 Summary: MCP configuration tool
 Author-email: Daniel Meppiel <user@example.com>
 License: MIT License
@@ -208,7 +208,7 @@ git add . && git commit -m "Initial standards" && git push
 
 Anyone can now `apm install you/my-standards`.
 
-## All Commands
+## Key Commands
 
 | Command | What it does |
 |---------|--------------|
@@ -217,8 +217,10 @@ Anyone can now `apm install you/my-standards`.
 | `apm init [name]` | Scaffold a new APM project or package |
 | `apm run <prompt>` | Execute a prompt workflow via AI runtime |
 | `apm uninstall <pkg>` | Remove a package from apm.yml and clean up its files |
+| `apm pack` | Bundle resolved dependencies for offline distribution |
 | `apm deps list` | Show installed packages and versions |
-| `apm compile --target` | Target a specific agent (`vscode`, `claude`, `all`) |
+
+→ [Full CLI Reference](docs/cli-reference.md)
 
 ## Configuration
 

{apm_cli-0.7.5 → apm_cli-0.7.7}/README.md

@@ -147,7 +147,7 @@ git add . && git commit -m "Initial standards" && git push
 
 Anyone can now `apm install you/my-standards`.
 
-## All Commands
+## Key Commands
 
 | Command | What it does |
 |---------|--------------|
@@ -156,8 +156,10 @@ Anyone can now `apm install you/my-standards`.
 | `apm init [name]` | Scaffold a new APM project or package |
 | `apm run <prompt>` | Execute a prompt workflow via AI runtime |
 | `apm uninstall <pkg>` | Remove a package from apm.yml and clean up its files |
+| `apm pack` | Bundle resolved dependencies for offline distribution |
 | `apm deps list` | Show installed packages and versions |
-| `apm compile --target` | Target a specific agent (`vscode`, `claude`, `all`) |
+
+→ [Full CLI Reference](docs/cli-reference.md)
 
 ## Configuration
 

{apm_cli-0.7.5 → apm_cli-0.7.7}/pyproject.toml

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

{apm_cli-0.7.5 → apm_cli-0.7.7}/src/apm_cli/adapters/client/codex.py

@@ -173,6 +173,15 @@ class CodexClientAdapter(MCPClientAdapter):
             "env": {},
             "id": server_info.get("id", "")  # Add registry UUID for conflict detection
         }
+
+        # Self-defined stdio deps carry raw command/args — use directly
+        raw = server_info.get("_raw_stdio")
+        if raw:
+            config["command"] = raw["command"]
+            config["args"] = raw["args"]
+            if raw.get("env"):
+                config["env"] = raw["env"]
+            return config
         
         # Note: Remote servers (SSE type) are handled in configure_mcp_server and rejected early
         # This method only handles local servers with packages

{apm_cli-0.7.5 → apm_cli-0.7.7}/src/apm_cli/adapters/client/copilot.py

@@ -165,6 +165,19 @@ class CopilotClientAdapter(MCPClientAdapter):
             "tools": ["*"],  # Required by Copilot CLI specification - default to all tools
             "id": server_info.get("id", "")  # Add registry UUID for conflict detection
         }
+
+        # Self-defined stdio deps carry raw command/args — use directly
+        raw = server_info.get("_raw_stdio")
+        if raw:
+            config["command"] = raw["command"]
+            config["args"] = raw["args"]
+            if raw.get("env"):
+                config["env"] = raw["env"]
+            # Apply tools override if present
+            tools_override = server_info.get("_apm_tools_override")
+            if tools_override:
+                config["tools"] = tools_override
+            return config
         
         # Check for remote endpoints first (registry-defined priority)
         remotes = server_info.get("remotes", [])

{apm_cli-0.7.5 → apm_cli-0.7.7}/src/apm_cli/adapters/client/vscode.py

@@ -186,6 +186,18 @@ class VSCodeClientAdapter(MCPClientAdapter):
         # Initialize the base config structure
         server_config = {}
         input_vars = []
+
+        # Self-defined stdio deps carry raw command/args — use directly
+        raw = server_info.get("_raw_stdio")
+        if raw:
+            server_config = {
+                "type": "stdio",
+                "command": raw["command"],
+                "args": raw["args"],
+            }
+            if raw.get("env"):
+                server_config["env"] = raw["env"]
+            return server_config, input_vars
         
         # Check for packages information
         if "packages" in server_info and server_info["packages"]:

apm_cli-0.7.7/src/apm_cli/bundle/__init__.py

@@ -0,0 +1,6 @@
+"""Bundle creation and consumption for APM packages."""
+
+from .packer import pack_bundle, PackResult
+from .unpacker import unpack_bundle, UnpackResult
+
+__all__ = ["pack_bundle", "PackResult", "unpack_bundle", "UnpackResult"]

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

@@ -0,0 +1,41 @@
+"""Lockfile enrichment for pack-time metadata."""
+
+from datetime import datetime, timezone
+
+from ..deps.lockfile import LockFile
+
+
+def enrich_lockfile_for_pack(
+    lockfile: LockFile,
+    fmt: str,
+    target: str,
+) -> str:
+    """Create an enriched copy of the lockfile YAML with a ``pack:`` section.
+
+    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 (``"vscode"``, ``"claude"``, ``"all"``).
+
+    Returns:
+        A YAML string with the ``pack:`` block followed by the original
+        lockfile content.
+    """
+    import yaml
+
+    pack_section = yaml.dump(
+        {
+            "pack": {
+                "format": fmt,
+                "target": target,
+                "packed_at": datetime.now(timezone.utc).isoformat(),
+            }
+        },
+        default_flow_style=False,
+        sort_keys=False,
+    )
+
+    return pack_section + lockfile.to_yaml()

apm_cli-0.7.7/src/apm_cli/bundle/packer.py

@@ -0,0 +1,175 @@
+"""Bundle packer — creates self-contained APM bundles from the resolved dependency tree."""
+
+import shutil
+import tarfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+from ..deps.lockfile import LockFile
+from ..models.apm_package import APMPackage
+from ..core.target_detection import detect_target
+from .lockfile_enrichment import enrich_lockfile_for_pack
+
+
+# Target prefix mapping ("copilot" and "vscode" both map to .github/)
+_TARGET_PREFIXES = {
+    "copilot": [".github/"],
+    "vscode": [".github/"],
+    "claude": [".claude/"],
+    "all": [".github/", ".claude/"],
+}
+
+
+@dataclass
+class PackResult:
+    """Result of a pack operation."""
+
+    bundle_path: Path
+    files: List[str] = field(default_factory=list)
+    lockfile_enriched: bool = False
+
+
+def _filter_files_by_target(deployed_files: List[str], target: str) -> List[str]:
+    """Filter deployed file paths by target prefix."""
+    prefixes = _TARGET_PREFIXES.get(target, _TARGET_PREFIXES["all"])
+    return [f for f in deployed_files if any(f.startswith(p) for p in prefixes)]
+
+
+def pack_bundle(
+    project_root: Path,
+    output_dir: Path,
+    fmt: str = "apm",
+    target: Optional[str] = None,
+    archive: bool = False,
+    dry_run: bool = False,
+) -> PackResult:
+    """Create a self-contained bundle from installed APM dependencies.
+
+    Args:
+        project_root: Root of the project containing ``apm.lock`` 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*
+            (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.
+
+    Returns:
+        :class:`PackResult` describing what was (or would be) produced.
+
+    Raises:
+        FileNotFoundError: If ``apm.lock`` is missing.
+        ValueError: If deployed files referenced in the lockfile are missing on disk.
+    """
+    # 1. Read lockfile
+    lockfile_path = project_root / "apm.lock"
+    lockfile = LockFile.read(lockfile_path)
+    if lockfile is None:
+        raise FileNotFoundError(
+            "apm.lock not found — run 'apm install' first to resolve dependencies."
+        )
+
+    # 2. Read apm.yml for name / version / config target
+    apm_yml_path = project_root / "apm.yml"
+    try:
+        package = APMPackage.from_apm_yml(apm_yml_path)
+        pkg_name = package.name
+        pkg_version = package.version or "0.0.0"
+        config_target = package.target
+    except (FileNotFoundError, ValueError):
+        pkg_name = project_root.resolve().name
+        pkg_version = "0.0.0"
+        config_target = None
+
+    # 3. Resolve effective target
+    effective_target, _reason = detect_target(
+        project_root,
+        explicit_target=target,
+        config_target=config_target,
+    )
+    # For packing purposes, "minimal" means nothing to pack — treat as "all"
+    if effective_target == "minimal":
+        effective_target = "all"
+
+    # 4. Collect deployed_files from all dependencies, filtered by target
+    all_deployed: List[str] = []
+    for dep in lockfile.get_all_dependencies():
+        all_deployed.extend(dep.deployed_files)
+
+    filtered_files = _filter_files_by_target(all_deployed, effective_target)
+    # Deduplicate while preserving order
+    seen = set()
+    unique_files: List[str] = []
+    for f in filtered_files:
+        if f not in seen:
+            seen.add(f)
+            unique_files.append(f)
+
+    # 5. Verify each path is safe (no traversal) and exists on disk
+    project_root_resolved = project_root.resolve()
+    missing: List[str] = []
+    for rel_path in unique_files:
+        # Guard against absolute paths or path-traversal entries in deployed_files
+        p = Path(rel_path)
+        if p.is_absolute() or ".." in p.parts:
+            raise ValueError(
+                f"Refusing to pack unsafe path from lockfile: {rel_path!r}"
+            )
+        abs_path = project_root / rel_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}"
+            )
+        # deployed_files may reference directories (ending with /)
+        if not abs_path.exists():
+            missing.append(rel_path)
+    if missing:
+        raise ValueError(
+            f"The following deployed files are missing on disk — "
+            f"run 'apm install' to restore them:\n"
+            + "\n".join(f"  - {m}" for m in missing)
+        )
+
+    # Dry-run: return file list without writing anything
+    if dry_run:
+        bundle_dir = output_dir / f"{pkg_name}-{pkg_version}"
+        return PackResult(
+            bundle_path=bundle_dir,
+            files=unique_files,
+            lockfile_enriched=True,
+        )
+
+    # 6. Build output directory
+    bundle_dir = output_dir / f"{pkg_name}-{pkg_version}"
+    bundle_dir.mkdir(parents=True, exist_ok=True)
+
+    # 7. Copy files preserving directory structure
+    for rel_path in unique_files:
+        src = project_root / rel_path
+        dest = bundle_dir / rel_path
+        if src.is_dir():
+            shutil.copytree(src, dest, dirs_exist_ok=True)
+        else:
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dest)
+
+    # 8. Enrich lockfile copy and write to bundle
+    enriched_yaml = enrich_lockfile_for_pack(lockfile, fmt, effective_target)
+    (bundle_dir / "apm.lock").write_text(enriched_yaml, encoding="utf-8")
+
+    result = PackResult(
+        bundle_path=bundle_dir,
+        files=unique_files,
+        lockfile_enriched=True,
+    )
+
+    # 10. Archive if requested
+    if archive:
+        archive_path = output_dir / f"{pkg_name}-{pkg_version}.tar.gz"
+        with tarfile.open(archive_path, "w:gz") as tar:
+            tar.add(bundle_dir, arcname=bundle_dir.name)
+        shutil.rmtree(bundle_dir)
+        result.bundle_path = archive_path
+
+    return result

apm_cli-0.7.7/src/apm_cli/bundle/unpacker.py

@@ -0,0 +1,165 @@
+"""Bundle unpacker — extracts and verifies APM bundles."""
+
+import shutil
+import sys
+import tarfile
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List
+
+from ..deps.lockfile import LockFile
+
+
+@dataclass
+class UnpackResult:
+    """Result of an unpack operation."""
+
+    extracted_dir: Path
+    files: List[str] = field(default_factory=list)
+    verified: bool = False
+
+
+def unpack_bundle(
+    bundle_path: Path,
+    output_dir: Path = Path("."),
+    skip_verify: bool = False,
+    dry_run: bool = False,
+) -> UnpackResult:
+    """Extract and apply an APM bundle to a project directory.
+
+    Additive-only semantics (v1): only writes files listed in the bundle's
+    lockfile ``deployed_files``.  Never deletes existing files.  If a local
+    file has the same name as a bundle file, the bundle file wins (overwrite).
+
+    Args:
+        bundle_path: Path to a ``.tar.gz`` archive or an unpacked bundle directory.
+        output_dir: Target project directory to copy files into.
+        skip_verify: If *True*, skip completeness verification against the lockfile.
+        dry_run: If *True*, resolve the file list but write nothing to disk.
+
+    Returns:
+        :class:`UnpackResult` describing what was (or would be) extracted.
+
+    Raises:
+        FileNotFoundError: If the bundle's ``apm.lock`` is missing.
+        ValueError: If verification finds files listed in the lockfile but
+            absent from the bundle.
+    """
+    # 1. If archive, extract to temp dir
+    cleanup_temp = False
+    if bundle_path.is_file() and bundle_path.name.endswith(".tar.gz"):
+        temp_dir = Path(tempfile.mkdtemp(prefix="apm-unpack-"))
+        cleanup_temp = True
+        try:
+            with tarfile.open(bundle_path, "r:gz") as tar:
+                # Security: prevent path traversal
+                for member in tar.getmembers():
+                    if member.name.startswith("/") or ".." in member.name:
+                        raise ValueError(
+                            f"Refusing to extract path-traversal entry: {member.name}"
+                        )
+                # filter="data" was added in Python 3.12; use it when available
+                if sys.version_info >= (3, 12):
+                    tar.extractall(temp_dir, filter="data")
+                else:
+                    tar.extractall(temp_dir)  # noqa: S202 — manual checks above
+        except Exception:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            raise
+
+        # Locate inner directory (the archive wraps a single top-level dir)
+        children = list(temp_dir.iterdir())
+        if len(children) == 1 and children[0].is_dir():
+            source_dir = children[0]
+        else:
+            source_dir = temp_dir
+    elif bundle_path.is_dir():
+        source_dir = bundle_path
+        temp_dir = None
+    else:
+        raise FileNotFoundError(f"Bundle not found or unsupported format: {bundle_path}")
+
+    try:
+        # 2. Read apm.lock from bundle
+        lockfile_path = source_dir / "apm.lock"
+        lockfile = LockFile.read(lockfile_path)
+        if lockfile is None:
+            if not lockfile_path.exists():
+                raise FileNotFoundError(
+                    "apm.lock not found in the bundle — the bundle may be incomplete."
+                )
+            raise FileNotFoundError(
+                "apm.lock in the bundle could not be parsed — the bundle may be corrupt."
+            )
+
+        # Collect all deployed_files from lockfile
+        all_deployed: list[str] = []
+        for dep in lockfile.get_all_dependencies():
+            all_deployed.extend(dep.deployed_files)
+
+        # Deduplicate
+        seen: set[str] = set()
+        unique_files: list[str] = []
+        for f in all_deployed:
+            if f not in seen:
+                seen.add(f)
+                unique_files.append(f)
+
+        # 3. Verify completeness
+        verified = True
+        if not skip_verify:
+            missing = [
+                f for f in unique_files if not (source_dir / f).exists()
+            ]
+            if missing:
+                raise ValueError(
+                    "Bundle verification failed — the following deployed files "
+                    "are missing from the bundle:\n"
+                    + "\n".join(f"  - {m}" for m in missing)
+                )
+
+        if skip_verify:
+            verified = False
+
+        # Dry-run: return file list without writing
+        if dry_run:
+            return UnpackResult(
+                extracted_dir=bundle_path,
+                files=unique_files,
+                verified=verified,
+            )
+
+        # 4. Copy target files to output_dir (additive, no deletes)
+        output_dir = Path(output_dir)
+        output_dir_resolved = output_dir.resolve()
+        for rel_path in unique_files:
+            # Guard against absolute paths or path-traversal entries in deployed_files
+            p = Path(rel_path)
+            if p.is_absolute() or ".." in p.parts:
+                raise ValueError(
+                    f"Refusing to unpack unsafe path from bundle lockfile: {rel_path!r}"
+                )
+            dest = output_dir / rel_path
+            if not dest.resolve().is_relative_to(output_dir_resolved):
+                raise ValueError(
+                    f"Refusing to unpack path that escapes output directory: {rel_path!r}"
+                )
+            src = source_dir / rel_path
+            if not src.exists():
+                continue  # skip_verify may allow missing files
+            if src.is_dir():
+                shutil.copytree(src, dest, dirs_exist_ok=True)
+            else:
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(src, dest)
+
+        return UnpackResult(
+            extracted_dir=bundle_path,
+            files=unique_files,
+            verified=verified,
+        )
+    finally:
+        # Clean up temp dir if we created one
+        if cleanup_temp and temp_dir is not None:
+            shutil.rmtree(temp_dir, ignore_errors=True)