apm-cli 0.14.2__tar.gz → 0.16.0__tar.gz

{apm_cli-0.14.2/src/apm_cli.egg-info → apm_cli-0.16.0}/PKG-INFO

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

{apm_cli-0.14.2 → apm_cli-0.16.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "apm-cli"
-version = "0.14.2"
+version = "0.16.0"
 description = "MCP configuration tool"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -165,5 +165,6 @@ markers = [
     "requires_runtime_copilot: requires GitHub Copilot CLI runtime installed",
     "requires_runtime_llm: requires llm runtime installed",
     "requires_inference: requires APM_RUN_INFERENCE_TESTS=1 + model API access",
+    "req: binds a test to one or more OpenAPM req-XXX ids (spec-conformance suite)",
 ]
 

apm_cli-0.16.0/src/apm_cli/adapters/client/_mcp_runtime_args.py

@@ -0,0 +1,61 @@
+"""Shared helper for MCP v0.1 runtimeArguments.variables handling.
+
+Extracted to avoid R0801 duplicate-code violations across adapter modules
+that each implement a ``_process_arguments`` method but share identical v0.1
+``value_hint`` processing logic (copilot and codex).
+
+Usage in an adapter's ``_process_arguments`` loop::
+
+    from ._mcp_runtime_args import process_v01_value_hint_arg
+
+    elif not arg_type and "value_hint" in arg:
+        value = process_v01_value_hint_arg(arg, runtime_vars)
+        if value:
+            processed.append(self._resolve_variable_placeholders(
+                value, resolved_env, runtime_vars
+            ))
+"""
+
+from __future__ import annotations
+
+
+def process_v01_value_hint_arg(arg: dict, runtime_vars: dict | None) -> str | None:
+    """Process a single v0.1-format runtimeArguments entry.
+
+    A v0.1 entry has a ``value_hint`` key but no ``type`` key.  An optional
+    ``variables`` dict maps placeholder names to their metadata.
+
+    The ``is_required`` field on the *arg itself* controls whether the entry
+    participates in argument building.  Entries with ``is_required: False``
+    are optional hints that must be skipped -- VS Code's extractor only
+    includes entries with ``is_required: True``, so including them would
+    produce extra, unintended CLI args.  When ``is_required`` is absent the
+    entry is treated as required (default True).
+
+    Args:
+        arg: The argument dict to process.  Must contain ``value_hint``.
+        runtime_vars: Resolved APM template variables (may be ``None`` or
+            empty).
+
+    Returns:
+        The processed value string after ``{var_name}`` placeholder
+        substitution, or ``None`` if the entry should be skipped (optional
+        hint or empty value).
+    """
+    # Skip optional legacy hints that are not required.
+    if not arg.get("is_required", True):
+        return None
+
+    value: str = arg.get("value_hint", "")
+    if not value:
+        return None
+
+    if "variables" in arg:
+        for var_name in arg["variables"]:
+            if runtime_vars and var_name in runtime_vars:
+                replacement = runtime_vars[var_name]
+            else:
+                replacement = f"${{{var_name}}}"
+            value = value.replace(f"{{{var_name}}}", replacement)
+
+    return value or None

{apm_cli-0.14.2 → apm_cli-0.16.0}/src/apm_cli/adapters/client/claude.py

@@ -48,6 +48,28 @@ class ClaudeClientAdapter(CopilotClientAdapter):
     # See #1152 supply-chain analysis.
     _supports_runtime_env_substitution: bool = False
 
+    # Skill packages declare self-defined MCP launchers using the cross-tool
+    # converged path ``.agents/skills/<name>/...`` (see
+    # https://microsoft.github.io/apm/reference/targets-matrix/#skills-convergence).
+    # Claude is the only target that does NOT converge to ``.agents/skills/``
+    # -- it keeps ``.claude/skills/`` (see install/skill_path_migration.py:55).
+    # Rewrite the command prefix so ``.mcp.json`` points at where the launcher
+    # actually lives after deploy.
+    _CONVERGED_SKILL_PREFIX = ".agents/skills/"
+    _CLAUDE_SKILL_PREFIX = ".claude/skills/"
+
+    @classmethod
+    def _rewrite_self_defined_skill_command(cls, command: str) -> str:
+        if isinstance(command, str) and command.startswith(cls._CONVERGED_SKILL_PREFIX):
+            return cls._CLAUDE_SKILL_PREFIX + command[len(cls._CONVERGED_SKILL_PREFIX) :]
+        return command
+
+    def _format_server_config(self, server_info, env_overrides=None, runtime_vars=None):
+        config = super()._format_server_config(server_info, env_overrides, runtime_vars)
+        if isinstance(config, dict) and "command" in config:
+            config["command"] = self._rewrite_self_defined_skill_command(config["command"])
+        return config
+
     @staticmethod
     def _normalize_mcp_entry_for_claude_code(entry: dict) -> dict:
         """Normalize a server entry to Claude Code's on-disk shape.

{apm_cli-0.14.2 → apm_cli-0.16.0}/src/apm_cli/adapters/client/codex.py

@@ -10,6 +10,7 @@ import toml
 from ...registry.client import SimpleRegistryClient
 from ...registry.integration import RegistryIntegration
 from ...utils.console import _rich_success, _rich_warning
+from ._mcp_runtime_args import process_v01_value_hint_arg
 from .base import MCPClientAdapter
 
 _log = logging.getLogger(__name__)
@@ -422,6 +423,15 @@ class CodexClientAdapter(MCPClientAdapter):
                                 str(additional_value), resolved_env, runtime_vars
                             )
                             processed.append(processed_value)
+                elif not arg_type and "value_hint" in arg:
+                    # v0.1 registry format: shared helper handles is_required
+                    # guard and {var_name} placeholder substitution.
+                    value = process_v01_value_hint_arg(arg, runtime_vars)
+                    if value:
+                        processed_value = self._resolve_variable_placeholders(
+                            value, resolved_env, runtime_vars
+                        )
+                        processed.append(processed_value)
             elif isinstance(arg, str):
                 # Already a string, use as-is but resolve variable placeholders
                 processed_value = self._resolve_variable_placeholders(

{apm_cli-0.14.2 → apm_cli-0.16.0}/src/apm_cli/adapters/client/copilot.py

@@ -18,6 +18,7 @@ from ...registry.client import SimpleRegistryClient
 from ...registry.integration import RegistryIntegration
 from ...utils.console import _rich_warning
 from ...utils.github_host import is_github_hostname
+from ._mcp_runtime_args import process_v01_value_hint_arg
 from .base import (
     _ENV_PLACEHOLDER_RE,
     _ENV_VAR_RE,
@@ -982,6 +983,15 @@ class CopilotClientAdapter(MCPClientAdapter):
                                 str(value), resolved_env, runtime_vars
                             )
                             processed.append(processed_value)
+                elif not arg_type and "value_hint" in arg:
+                    # v0.1 registry format: shared helper handles is_required
+                    # guard and {var_name} placeholder substitution.
+                    value = process_v01_value_hint_arg(arg, runtime_vars)
+                    if value:
+                        processed_value = self._resolve_variable_placeholders(
+                            value, resolved_env, runtime_vars
+                        )
+                        processed.append(processed_value)
             elif isinstance(arg, str):
                 # Already a string, use as-is but resolve variable placeholders
                 processed_value = self._resolve_variable_placeholders(

{apm_cli-0.14.2 → apm_cli-0.16.0}/src/apm_cli/cache/git_cache.py

@@ -45,6 +45,32 @@ _log = logging.getLogger(__name__)
 # Full SHA pattern: 40 hex characters
 _SHA_RE = re.compile(r"^[0-9a-f]{40}$", re.IGNORECASE)
 
+
+def _safe_git_args() -> list[str]:
+    """Return hardening ``-c`` args prepended to every git subprocess.
+
+    - ``core.hooksPath=/dev/null`` disables any hook script that a
+      malicious upstream might ship (``.git/hooks/post-checkout`` etc.)
+      so a clone or checkout cannot trigger arbitrary code execution.
+    - ``submodule.recurse=false`` prevents any subcommand from
+      recursing into attacker-controlled submodule URLs.
+
+    These flags are scoped per-invocation via ``-c`` and never mutate
+    the user's gitconfig. The cache layer is the single source of
+    truth for git subprocess invocation -- callers must use this
+    helper rather than ad-hoc ``git`` argv construction.
+    """
+    from ..utils.git_env import git_long_paths_args
+
+    return [
+        *git_long_paths_args(),
+        "-c",
+        "core.hooksPath=/dev/null",
+        "-c",
+        "submodule.recurse=false",
+    ]
+
+
 # Partial bare-cache flavor suffix (perf #1433 follow-up).
 # When a caller requests sparse_paths, we use a separate bare keyed at
 # ``<shard>__p`` cloned with ``--filter=blob:none``. The partial bare
@@ -214,7 +240,7 @@ class GitCache:
         # auth-delegated: cache-layer ref resolution runs after lockfile
         # already pinned the commit; no PAT->bearer fallback applies here
         # (env is sanitized, no embedded creds).
-        cmd = [git_exe, "ls-remote", url]
+        cmd = [git_exe, *_safe_git_args(), "ls-remote", url]
         if ref:
             cmd.append(ref)
 
@@ -287,7 +313,7 @@ class GitCache:
 
         Returns the path to the bare repo directory.
         """
-        from ..utils.git_env import get_git_executable, git_long_paths_args, git_subprocess_env
+        from ..utils.git_env import get_git_executable, git_subprocess_env
 
         bare_shard = shard_key + (_PARTIAL_BARE_SUFFIX if partial else "")
         bare_dir = self._db_root / bare_shard
@@ -318,7 +344,14 @@ class GitCache:
             os.chmod(str(staged), 0o700)
 
             subprocess_env = env if env is not None else git_subprocess_env()
-            clone_args = [git_exe, *git_long_paths_args(), "clone", "--bare", "--no-tags"]
+            clone_args = [
+                git_exe,
+                *_safe_git_args(),
+                "clone",
+                "--bare",
+                "--no-tags",
+                "--no-recurse-submodules",
+            ]
             if partial:
                 # Promisor partial clone: trees + commits only. Blobs
                 # arrive lazily via the remote when the consumer needs
@@ -368,10 +401,11 @@ class GitCache:
                         subprocess.run(
                             [
                                 git_exe,
-                                *git_long_paths_args(),
+                                *_safe_git_args(),
                                 "clone",
                                 "--bare",
                                 "--no-tags",
+                                "--no-recurse-submodules",
                                 url,
                                 str(staged),
                             ],
@@ -456,7 +490,7 @@ class GitCache:
         get the lock and return immediately. Critical for CI matrix
         builds where multiple jobs hit the same uncached repo.
         """
-        from ..utils.git_env import get_git_executable, git_long_paths_args, git_subprocess_env
+        from ..utils.git_env import get_git_executable, git_subprocess_env
 
         bare_shard = shard_key + (_PARTIAL_BARE_SUFFIX if promisor_url else "")
         bare_dir = self._db_root / bare_shard
@@ -505,11 +539,12 @@ class GitCache:
                 subprocess.run(
                     [
                         git_exe,
-                        *git_long_paths_args(),
+                        *_safe_git_args(),
                         "clone",
                         "--local",
                         "--shared",
                         "--no-checkout",
+                        "--no-recurse-submodules",
                         str(bare_dir),
                         str(staged),
                     ],
@@ -536,7 +571,7 @@ class GitCache:
                         subprocess.run(
                             [
                                 git_exe,
-                                *git_long_paths_args(),
+                                *_safe_git_args(),
                                 "-C",
                                 str(staged),
                                 "config",
@@ -558,13 +593,13 @@ class GitCache:
                         staged,
                         list(sparse_paths),
                         env=subprocess_env,
-                        extra_git_args=git_long_paths_args(),
+                        extra_git_args=_safe_git_args(),
                     )
                 # Checkout the specific SHA
                 subprocess.run(
                     [
                         git_exe,
-                        *git_long_paths_args(),
+                        *_safe_git_args(),
                         "-C",
                         str(staged),
                         "checkout",
@@ -606,7 +641,7 @@ class GitCache:
         subprocess_env = env if env is not None else git_subprocess_env()
         try:
             result = subprocess.run(
-                [git_exe, "-C", str(bare_dir), "cat-file", "-t", sha],
+                [git_exe, *_safe_git_args(), "-C", str(bare_dir), "cat-file", "-t", sha],
                 capture_output=True,
                 text=True,
                 timeout=10,
@@ -648,7 +683,7 @@ class GitCache:
         # so we don't pull all blobs reachable from the new SHA. Detected
         # via shard-suffix naming convention (cheap, no git config probe).
         is_partial = bare_dir.name.endswith(_PARTIAL_BARE_SUFFIX)
-        fetch_args = [git_exe, "-C", str(bare_dir), "fetch"]
+        fetch_args = [git_exe, *_safe_git_args(), "-C", str(bare_dir), "fetch"]
         if is_partial:
             fetch_args += ["--filter=blob:none"]
         fetch_args += [url, sha]
@@ -664,7 +699,7 @@ class GitCache:
         except subprocess.CalledProcessError:
             # Some servers don't allow fetching by SHA -- fetch all refs
             subprocess.run(
-                [git_exe, "-C", str(bare_dir), "fetch", "--all"],
+                [git_exe, *_safe_git_args(), "-C", str(bare_dir), "fetch", "--all"],
                 capture_output=True,
                 text=True,
                 timeout=120,

{apm_cli-0.14.2 → apm_cli-0.16.0}/src/apm_cli/cli.py

@@ -34,6 +34,7 @@ from apm_cli.commands.pack import pack_cmd, unpack_cmd
 from apm_cli.commands.plugin import plugin as plugin_cmd
 from apm_cli.commands.policy import policy
 from apm_cli.commands.prune import prune
+from apm_cli.commands.publish import publish_cmd
 from apm_cli.commands.run import preview, run
 from apm_cli.commands.runtime import runtime
 from apm_cli.commands.self_update import self_update
@@ -87,6 +88,7 @@ cli.add_command(
 )
 cli.add_command(pack_cmd, name="pack")
 cli.add_command(unpack_cmd, name="unpack")
+cli.add_command(publish_cmd, name="publish")
 cli.add_command(init)
 cli.add_command(install)
 cli.add_command(uninstall)

{apm_cli-0.14.2 → apm_cli-0.16.0}/src/apm_cli/commands/compile/cli.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import dataclasses
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -521,6 +522,17 @@ def compile(
 
         # Watch mode
         if watch:
+            # --clean removes orphaned outputs from a previous targets:
+            # configuration and would surprise users if run on every
+            # recompile mid-session; running it only on the initial
+            # compile would re-introduce a watcher-specific code path.
+            # Surface that --clean is ignored here so users can run
+            # `apm compile --clean` separately between watch sessions.
+            if clean:
+                logger.warning(
+                    "--clean is ignored in watch mode; run 'apm compile --clean' "
+                    "separately to remove orphaned outputs."
+                )
             # Resolve the same effective target the one-shot path uses so
             # `targets: [claude, cursor]` does not silently regress to the
             # all-families fanout on every recompile (#1345).
@@ -534,6 +546,7 @@ def compile(
                 effective_target=effective_target,
                 target_label_user=target,
                 target_label_config=config_target,
+                cli_target=target,
             )
             return
 
@@ -775,15 +788,10 @@ def compile(
             else:
                 # Traditional single-file compilation - keep existing logic
                 # Perform initial compilation in dry-run to get generated body (without constitution)
-                # TODO: Refactor to use dataclasses.replace() once CompilationConfig fields stabilise
-                intermediate_config = CompilationConfig(
-                    output_path=config.output_path,
-                    chatmode=config.chatmode,
-                    resolve_links=config.resolve_links,
+                intermediate_config = dataclasses.replace(
+                    config,
                     dry_run=True,  # force
-                    with_constitution=config.with_constitution,
                     strategy="single-file",
-                    target=config.target,
                 )
                 intermediate_result = compiler.compile(intermediate_config)
 

{apm_cli-0.14.2 → apm_cli-0.16.0}/src/apm_cli/commands/compile/watcher.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 import time
 from typing import TYPE_CHECKING, Any
 
@@ -67,6 +68,7 @@ class APMFileHandler:
         dry_run: bool,
         logger: CommandLogger,
         effective_target: CompileTargetType | None = None,
+        cli_target: str | list[str] | None = None,
     ) -> None:
         self.output = output
         self.chatmode = chatmode
@@ -74,6 +76,11 @@ class APMFileHandler:
         self.dry_run = dry_run
         self.logger = logger
         self.effective_target = effective_target
+        # Raw --target CLI argument retained so ``_recompile`` can
+        # re-run :func:`_resolve_effective_target` against the
+        # current apm.yml on every recompile, letting mid-session
+        # ``targets:`` edits take effect on the next file event.
+        self.cli_target = cli_target
         self.last_compile = 0.0
         self.debounce_delay = 1.0  # 1 second debounce
 
@@ -95,12 +102,28 @@ class APMFileHandler:
             self.logger.progress(f"File changed: {changed_file}", symbol="eyes")
             self.logger.progress("Recompiling...", symbol="gear")
 
+            # When apm.yml itself was the trigger, re-resolve so a
+            # mid-session edit to ``target:`` / ``targets:`` takes
+            # effect on this recompile, then persist the fresh value
+            # so subsequent instruction-file edits do not silently
+            # revert to the startup snapshot.  Match on basename
+            # rather than ``endswith`` so a stray ``backup_apm.yml``
+            # cannot masquerade as the project root manifest.
+            effective_target = self.effective_target
+            if os.path.basename(changed_file) == APM_YML_FILENAME:
+                from .cli import _resolve_effective_target
+
+                effective_target, _reason, _config_target = _resolve_effective_target(
+                    self.cli_target
+                )
+                self.effective_target = effective_target
+
             config = CompilationConfig.from_apm_yml(
                 output_path=self.output if self.output != AGENTS_MD_FILENAME else None,
                 chatmode=self.chatmode,
                 resolve_links=not self.no_links if self.no_links else None,
                 dry_run=self.dry_run,
-                target=self.effective_target,
+                target=effective_target,
             )
 
             compiler = AgentsCompiler(".")
@@ -129,15 +152,20 @@ def _watch_mode(
     effective_target: CompileTargetType | None = None,
     target_label_user: str | list[str] | None = None,
     target_label_config: str | list[str] | None = None,
+    cli_target: str | list[str] | None = None,
 ) -> None:
     """Watch for changes in .apm/ directories and auto-recompile.
 
     ``effective_target`` is the compiler-understood target resolved by
     :func:`apm_cli.commands.compile.cli._resolve_effective_target` (the
     same resolver the one-shot path uses) and is forwarded as ``target=``
-    into every :meth:`CompilationConfig.from_apm_yml` call so watch mode
-    honors ``targets: [claude, cursor]`` instead of silently fanning out
-    to all families on every recompile (#1345).
+    into the initial compile so the startup label matches the one-shot
+    path (#1345).
+
+    ``cli_target`` is the raw ``--target`` argument; recompiles re-run
+    the resolver against the current apm.yml so mid-session edits to
+    ``targets:`` take effect on the next file event without restarting
+    the watcher.
     """
     logger = CommandLogger("compile-watch", verbose=verbose, dry_run=dry_run)
 
@@ -159,6 +187,7 @@ def _watch_mode(
             dry_run,
             logger,
             effective_target=effective_target,
+            cli_target=cli_target,
         )
         observer = Observer()