apm-cli 0.27.0__tar.gz → 0.28.0__tar.gz

{apm_cli-0.27.0/src/apm_cli.egg-info → apm_cli-0.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apm-cli
-Version: 0.27.0
+Version: 0.28.0
 Summary: MCP configuration tool
 Author-email: Daniel Meppiel <user@example.com>
 License: MIT License
@@ -76,7 +76,7 @@ Dynamic: license-file
 
 Think `package.json`, `requirements.txt`, or `Cargo.toml` — but for AI agent configuration.
 
-GitHub Copilot · Claude Code · Cursor · OpenCode · Codex · Gemini · Windsurf · Kiro
+GitHub Copilot | Claude Code | Grok Build | Cursor | OpenCode | Codex | Gemini | Windsurf | Kiro
 
 **[Documentation](https://microsoft.github.io/apm/)** · **[Quick Start](https://microsoft.github.io/apm/getting-started/quick-start/)** · **[CLI Reference](https://microsoft.github.io/apm/reference/cli-commands/)** · **[Roadmap](https://github.com/orgs/microsoft/projects/2304)**
 
@@ -139,7 +139,7 @@ One command, no configuration -- VS Code and GitHub Copilot read the file automa
 
 One `apm.yml` describes every primitive your agents need — instructions, skills, prompts, agents, hooks, plugins, MCP servers — and `apm install` reproduces the exact same setup across every client on every machine. `apm.lock.yaml` pins the resolved tree the way `package-lock.json` does for npm.
 
-- **[One manifest for everything](https://microsoft.github.io/apm/reference/primitive-types/)** — declared once, deployed across Copilot, Claude, Cursor, OpenCode, Codex, Gemini, Windsurf, Kiro
+- **[One manifest for everything](https://microsoft.github.io/apm/reference/primitive-types/)** -- declared once, deployed across Copilot, Claude, Grok Build, Cursor, OpenCode, Codex, Gemini, Windsurf, Kiro
 - **[Install from anywhere](https://microsoft.github.io/apm/guides/dependencies/)** — GitHub, GitLab, Bitbucket, Azure DevOps, GitHub Enterprise, Gitea, Gogs, any git host
 - **[Transitive dependencies](https://microsoft.github.io/apm/guides/dependencies/)** — packages can depend on packages; APM resolves the full tree
 - **[Author plugins](https://microsoft.github.io/apm/guides/plugins/)** — build Copilot, Claude, and Cursor plugins with dependency management, then export standard `plugin.json`

{apm_cli-0.27.0 → apm_cli-0.28.0}/README.md

@@ -4,7 +4,7 @@
 
 Think `package.json`, `requirements.txt`, or `Cargo.toml` — but for AI agent configuration.
 
-GitHub Copilot · Claude Code · Cursor · OpenCode · Codex · Gemini · Windsurf · Kiro
+GitHub Copilot | Claude Code | Grok Build | Cursor | OpenCode | Codex | Gemini | Windsurf | Kiro
 
 **[Documentation](https://microsoft.github.io/apm/)** · **[Quick Start](https://microsoft.github.io/apm/getting-started/quick-start/)** · **[CLI Reference](https://microsoft.github.io/apm/reference/cli-commands/)** · **[Roadmap](https://github.com/orgs/microsoft/projects/2304)**
 
@@ -67,7 +67,7 @@ One command, no configuration -- VS Code and GitHub Copilot read the file automa
 
 One `apm.yml` describes every primitive your agents need — instructions, skills, prompts, agents, hooks, plugins, MCP servers — and `apm install` reproduces the exact same setup across every client on every machine. `apm.lock.yaml` pins the resolved tree the way `package-lock.json` does for npm.
 
-- **[One manifest for everything](https://microsoft.github.io/apm/reference/primitive-types/)** — declared once, deployed across Copilot, Claude, Cursor, OpenCode, Codex, Gemini, Windsurf, Kiro
+- **[One manifest for everything](https://microsoft.github.io/apm/reference/primitive-types/)** -- declared once, deployed across Copilot, Claude, Grok Build, Cursor, OpenCode, Codex, Gemini, Windsurf, Kiro
 - **[Install from anywhere](https://microsoft.github.io/apm/guides/dependencies/)** — GitHub, GitLab, Bitbucket, Azure DevOps, GitHub Enterprise, Gitea, Gogs, any git host
 - **[Transitive dependencies](https://microsoft.github.io/apm/guides/dependencies/)** — packages can depend on packages; APM resolves the full tree
 - **[Author plugins](https://microsoft.github.io/apm/guides/plugins/)** — build Copilot, Claude, and Cursor plugins with dependency management, then export standard `plugin.json`

{apm_cli-0.27.0 → apm_cli-0.28.0}/pyproject.toml

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

{apm_cli-0.27.0 → apm_cli-0.28.0}/src/apm_cli/adapters/client/base.py

@@ -29,6 +29,7 @@ _ENV_PLACEHOLDER_RE = re.compile(r"<([A-Z_][A-Z0-9_]*)>|" + _ENV_VAR_RE.pattern)
 # Detects the legacy ``<VAR>`` placeholder syntax only. Used to aggregate
 # deprecation warnings across all servers in a single install run.
 _LEGACY_ANGLE_VAR_RE = re.compile(r"<([A-Z_][A-Z0-9_]*)>")
+_RUNTIME_TEMPLATE_VARIABLE_RE = re.compile(r"(?<!\$)\{([a-zA-Z_][a-zA-Z0-9_]*)\}")
 
 # MCP Registry v0.1 names the container registry type ``oci``; the adapters
 # below key their launcher dispatch on ``docker`` (the vocabulary the legacy
@@ -656,6 +657,94 @@ class MCPClientAdapter(ABC):
             None,
         )
 
+    @staticmethod
+    def _package_runtime_variable_metadata(
+        package: dict[str, Any] | None,
+    ) -> dict[str, dict] | None:
+        """Return one validated runtime-variable declaration map for a package.
+
+        Registry metadata may declare a variable on one argument and reference it
+        later without repeating the declaration. Keeping this map package-scoped
+        makes those references resolve consistently while rejecting malformed
+        secret metadata before an adapter can render a collected value.
+        """
+        metadata_by_name: dict[str, dict] = {}
+        for field_name in ("runtime_arguments", "package_arguments"):
+            for argument in (package or {}).get(field_name) or []:
+                if not isinstance(argument, dict):
+                    continue
+                variables = argument.get("variables")
+                if variables is None:
+                    continue
+                if not isinstance(variables, dict):
+                    return None
+                for name, metadata in variables.items():
+                    if not isinstance(name, str) or not isinstance(metadata, dict):
+                        return None
+                    secret_marker = metadata.get("isSecret", metadata.get("is_secret", False))
+                    if not isinstance(secret_marker, bool):
+                        return None
+                    existing = metadata_by_name.get(name)
+                    if existing is not None and existing != metadata:
+                        return None
+                    metadata_by_name[name] = metadata
+        return metadata_by_name
+
+    @staticmethod
+    def _substitute_runtime_variables(
+        template: str,
+        variables: dict[object, object] | None,
+        runtime_vars: dict[str, object] | None,
+        runtime_variable_fallbacks: dict[str, str] | None = None,
+        secret_variable_fallbacks: dict[str, str] | None = None,
+    ) -> str | None:
+        """Resolve every APM runtime variable in one registry argument template.
+
+        Variable metadata may appear on an earlier argument while later
+        arguments reference the same value. Collected values therefore apply to
+        every template, not only the metadata-bearing entry. Target-specific
+        fallbacks are used only for declared variables with no collected value.
+        """
+        secret_fallbacks = secret_variable_fallbacks or {}
+        values: dict[str, str] = dict(secret_fallbacks)
+        for name, value in (runtime_vars or {}).items():
+            if (
+                isinstance(name, str)
+                and name not in secret_fallbacks
+                and value is not None
+                and str(value) != ""
+            ):
+                values[name] = str(value)
+
+        fallbacks = runtime_variable_fallbacks or {}
+        for name, metadata in (variables or {}).items():
+            if not isinstance(name, str) or not isinstance(metadata, dict):
+                return None
+            placeholder = f"{{{name}}}"
+            if placeholder not in template or name in values:
+                continue
+            secret_marker = metadata.get("isSecret", metadata.get("is_secret", False))
+            if not isinstance(secret_marker, bool):
+                return None
+            if secret_marker is True:
+                return None
+            fallback = fallbacks.get(name)
+            if fallback is not None:
+                values[name] = fallback
+                continue
+            configured = metadata.get("value", metadata.get("default"))
+            if isinstance(configured, str) and configured:
+                values[name] = configured
+            elif configured is not None:
+                return None
+
+        for name, value in values.items():
+            template = template.replace(f"{{{name}}}", value)
+
+        if _RUNTIME_TEMPLATE_VARIABLE_RE.search(template):
+            return None
+        return template
+
     @staticmethod
     def _processed_non_container_argument_groups(
         arguments: list[object],

{apm_cli-0.27.0 → apm_cli-0.28.0}/src/apm_cli/adapters/client/vscode.py

@@ -5,6 +5,7 @@ following the official documentation at:
 https://code.visualstudio.com/docs/copilot/chat/mcp-servers
 """
 
+import hashlib
 import json
 import re
 from pathlib import Path
@@ -13,7 +14,13 @@ from ...core.docker_args import DockerArgsProcessor
 from ...registry.client import SimpleRegistryClient
 from ...registry.integration import RegistryIntegration
 from ...utils.console import _rich_warning
-from .base import _ENV_VAR_RE, _INPUT_VAR_RE, MCPClientAdapter, registry_field_is_required
+from .base import (
+    _ENV_VAR_RE,
+    _INPUT_VAR_RE,
+    _RUNTIME_TEMPLATE_VARIABLE_RE,
+    MCPClientAdapter,
+    registry_field_is_required,
+)
 
 # Legacy ``<VAR>`` placeholder (Copilot CLI / Codex only). VS Code does not
 # resolve angle-bracket placeholders, so emitting them produces literal
@@ -298,7 +305,8 @@ class VSCodeClientAdapter(MCPClientAdapter):
                 existing_server_config=existing_server_config,
             )
             secret_fallbacks, argument_inputs = self._declared_vscode_argument_secret_inputs(
-                package
+                package,
+                server_name=server_info.get("name", ""),
             )
             seen_input_ids = {item.get("id") for item in input_vars}
             for input_definition in (*declared_inputs, *argument_inputs):
@@ -342,19 +350,29 @@ class VSCodeClientAdapter(MCPClientAdapter):
 
             # Handle docker packages
             elif is_docker:
-                args = self._docker_run_args(package, runtime_vars)
+                docker_kwargs = (
+                    {"secret_variable_fallbacks": secret_fallbacks} if secret_fallbacks else {}
+                )
+                unresolved_variables: list[str] = []
+                args = self._docker_run_args(
+                    package,
+                    runtime_vars,
+                    unresolved_variables=unresolved_variables,
+                    **docker_kwargs,
+                )
                 if args is None:
                     if package.get("runtime_arguments") or package.get("package_arguments"):
+                        variable_name = (
+                            unresolved_variables[0] if unresolved_variables else "unknown"
+                        )
                         _rich_warning(
-                            "Could not resolve container run options for "
-                            f"'{package.get('name', '')}'; using the default launcher. "
-                            "Set the required registry runtime variables and rerun "
-                            "'apm install'."
+                            "Could not resolve required container run option "
+                            f"'{variable_name}' for '{package.get('name', '')}'; "
+                            "target configuration was not changed. Set the required "
+                            "registry runtime variables and rerun 'apm install'."
                         )
-                    args = self._ensure_docker_image_arg(
-                        ["run", "-i", "--rm"],
-                        package.get("name"),
-                    )
+                        return {}, []
+                    args = self._ensure_docker_image_arg(["run", "-i", "--rm"], package.get("name"))
 
                 server_config = {"type": "stdio", "command": "docker", "args": args}
 
@@ -547,50 +565,50 @@ class VSCodeClientAdapter(MCPClientAdapter):
         return env_config, input_vars
 
     @staticmethod
-    def _declared_vscode_argument_secret_inputs(package):
+    def _vscode_argument_secret_input_id(server_name: str, variable_name: str) -> str:
+        """Return a collision-safe VS Code input ID for one server variable."""
+        server_digest = hashlib.sha256(server_name.encode("utf-8")).hexdigest()[:12]
+        return f"mcp-{server_digest}-{variable_name.encode('utf-8').hex()}"
+
+    @classmethod
+    def _declared_vscode_argument_secret_inputs(cls, package, *, server_name: str):
         """Return VS Code input indirections for secret argument variables."""
         if not package:
             return {}, []
+        package_variables = cls._package_runtime_variable_metadata(package)
+        if package_variables is None:
+            raise ValueError("MCP package argument variable metadata must be valid")
         fallbacks = {}
         input_vars = []
+        templates = []
         for field_name in ("runtime_arguments", "package_arguments"):
             for argument in package.get(field_name) or []:
                 if not isinstance(argument, dict):
                     continue
-                variables = argument.get("variables")
-                if not isinstance(variables, dict):
-                    continue
                 template = argument.get(
                     "value",
                     argument.get("default", argument.get("value_hint", "")),
                 )
-                for variable_name, variable_info in variables.items():
-                    if not isinstance(variable_name, str) or not isinstance(
-                        variable_info,
-                        dict,
-                    ):
-                        continue
-                    if not isinstance(template, str) or f"{{{variable_name}}}" not in template:
-                        continue
-                    is_secret = variable_info.get(
-                        "isSecret",
-                        variable_info.get("is_secret", False),
-                    )
-                    if is_secret is not True or variable_name in fallbacks:
-                        continue
-                    input_id = variable_name.lower().replace("_", "-")
-                    fallbacks[variable_name] = f"${{input:{input_id}}}"
-                    input_vars.append(
-                        {
-                            "type": "promptString",
-                            "id": input_id,
-                            "description": variable_info.get(
-                                "description",
-                                f"{variable_name} for MCP server",
-                            ),
-                            "password": True,
-                        }
-                    )
+                if isinstance(template, str):
+                    templates.append(template)
+        for variable_name, variable_info in package_variables.items():
+            if not any(f"{{{variable_name}}}" in template for template in templates):
+                continue
+            if not variable_info.get("isSecret", variable_info.get("is_secret", False)):
+                continue
+            input_id = cls._vscode_argument_secret_input_id(server_name, variable_name)
+            fallbacks[variable_name] = f"${{input:{input_id}}}"
+            input_vars.append(
+                {
+                    "type": "promptString",
+                    "id": input_id,
+                    "description": variable_info.get(
+                        "description",
+                        f"{variable_name} for MCP server",
+                    ),
+                    "password": True,
+                }
+            )
         return fallbacks, input_vars
 
     @staticmethod
@@ -776,7 +794,14 @@ class VSCodeClientAdapter(MCPClientAdapter):
         return extracted
 
     @classmethod
-    def _docker_run_args(cls, package: dict, runtime_vars: dict | None = None) -> list[str] | None:
+    def _docker_run_args(
+        cls,
+        package: dict,
+        runtime_vars: dict | None = None,
+        *,
+        secret_variable_fallbacks: dict[str, str] | None = None,
+        unresolved_variables: list[str] | None = None,
+    ) -> list[str] | None:
         """Build ``docker run`` arguments from a container package's metadata.
 
         Container packages retain a dedicated assembler because Docker requires
@@ -813,10 +838,27 @@ class VSCodeClientAdapter(MCPClientAdapter):
         """
         if not package:
             return None
-        run_options = cls._docker_arg_values(package.get("runtime_arguments"), runtime_vars)
+        package_variables = cls._package_runtime_variable_metadata(package)
+        if package_variables is None:
+            if unresolved_variables is not None:
+                unresolved_variables.append("invalid metadata")
+            return None
+        run_options = cls._docker_arg_values(
+            package.get("runtime_arguments"),
+            runtime_vars,
+            secret_variable_fallbacks,
+            package_variables,
+            unresolved_variables,
+        )
         if run_options is None:
             return None
-        package_args = cls._docker_arg_values(package.get("package_arguments"), runtime_vars)
+        package_args = cls._docker_arg_values(
+            package.get("package_arguments"),
+            runtime_vars,
+            secret_variable_fallbacks,
+            package_variables,
+            unresolved_variables,
+        )
         if package_args is None:
             return None
         if not run_options and package_args and package_args[0] == "run":
@@ -855,7 +897,12 @@ class VSCodeClientAdapter(MCPClientAdapter):
 
     @classmethod
     def _docker_arg_values(
-        cls, entries: list | None, runtime_vars: dict | None
+        cls,
+        entries: list | None,
+        runtime_vars: dict | None,
+        secret_variable_fallbacks: dict[str, str] | None,
+        package_variables: dict[str, dict],
+        unresolved_variables: list[str] | None,
     ) -> list[str] | None:
         """Resolve one registry argument list into CLI argument strings.
 
@@ -903,47 +950,26 @@ class VSCodeClientAdapter(MCPClientAdapter):
                 continue
 
             template = str(raw)
-            variables = arg.get("variables")
-            if isinstance(variables, dict) and variables:
-                substituted = cls._substitute_runtime_variables(template, variables, runtime_vars)
-                if substituted is None:
-                    if required:
-                        return None
-                    continue
-                template = substituted
+            substituted = cls._substitute_runtime_variables(
+                template,
+                package_variables,
+                runtime_vars,
+                {"workspaceFolder": "${workspaceFolder}"},
+                secret_variable_fallbacks,
+            )
+            if substituted is None:
+                if required:
+                    if unresolved_variables is not None:
+                        match = _RUNTIME_TEMPLATE_VARIABLE_RE.search(template)
+                        unresolved_variables.append(match.group(1) if match else "unknown")
+                    return None
+                continue
+            template = substituted
             if arg_type == "named" and arg.get("name"):
                 args.append(str(arg["name"]))
             args.append(template)
         return args
 
-    @staticmethod
-    def _substitute_runtime_variables(
-        template: str, variables: dict, runtime_vars: dict | None
-    ) -> str | None:
-        """Substitute ``{var}`` placeholders, or return None if unresolvable.
-
-        ``workspaceFolder`` resolves to VS Code's own ``${workspaceFolder}``
-        token, which the editor expands at server start. Any other name that
-        this install did not collect a value for has no such fallback, so the
-        caller is told to decline rather than write a literal ``${name}`` into
-        a mount path.
-        """
-        for var_name in variables:
-            placeholder = f"{{{var_name}}}"
-            # A descriptor the template never references cannot make it
-            # unresolvable; declining on one would drop a usable argument.
-            if placeholder not in template:
-                continue
-            supplied = (runtime_vars or {}).get(var_name)
-            if supplied is not None and str(supplied) != "":
-                replacement = str(supplied)
-            elif var_name == "workspaceFolder":
-                replacement = "${workspaceFolder}"
-            else:
-                return None
-            template = template.replace(placeholder, replacement)
-        return template
-
     @staticmethod
     def _select_remote_with_url(remotes):
         """Return the first remote entry that has a non-empty URL.

{apm_cli-0.27.0 → apm_cli-0.28.0}/src/apm_cli/bundle/lockfile_enrichment.py

@@ -46,6 +46,13 @@ _CROSS_TARGET_MAPS: dict[str, dict[str, str]] = {
         ".github/skills/": ".agents/skills/",
         ".github/agents/": ".windsurf/skills/",
     },
+    "grok-cloud": {
+        ".github/skills/": ".grok/skills/",
+    },
+    "grok-build": {
+        ".github/skills/": ".grok/skills/",
+        ".github/agents/": ".grok/agents/",
+    },
     "agent-skills": {
         ".github/skills/": ".agents/skills/",
     },
@@ -131,32 +138,30 @@ def _filter_files_by_target(
                 if p not in seen_prefixes:
                     seen_prefixes.add(p)
                     prefixes.append(p)
-        # Union all cross-target maps
-        # NOTE: dict.update() means the last target's mapping wins when
-        # multiple targets map the same source prefix. In practice this
-        # is benign -- common multi-target combos (e.g. claude+copilot)
-        # match prefixes directly without needing cross-maps.
-        cross_map: dict[str, str] = {}
+        # Preserve every selected target's cross-map so one source path can
+        # intentionally fan out to multiple target-specific destinations.
+        cross_maps: list[tuple[str, str]] = []
         for t in target:
-            cross_map.update(_CROSS_TARGET_MAPS.get(t, {}))
+            cross_maps.extend(_CROSS_TARGET_MAPS.get(t, {}).items())
     else:
         prefixes = _get_target_prefixes(target)
-        cross_map = _CROSS_TARGET_MAPS.get(target, {})
+        cross_maps = list(_CROSS_TARGET_MAPS.get(target, {}).items())
 
     direct = [f for f in deployed_files if any(f.startswith(p) for p in prefixes)]
 
     path_mappings: dict[str, str] = {}
-    if cross_map:
+    if cross_maps:
         direct_set = set(direct)
         for f in deployed_files:
             if f in direct_set:
                 continue
-            for src_prefix, dst_prefix in cross_map.items():
+            for src_prefix, dst_prefix in cross_maps:
                 if f.startswith(src_prefix):
                     mapped = dst_prefix + f[len(src_prefix) :]
                     # Containment guard: normalise the remapped path and
-                    # reject any result that escapes the destination prefix
-                    # via traversal segments (e.g. "../../etc/passwd").
+                    # reject any result that escapes the destination prefix.
+                    # The ".." check catches root-level escapes; the prefix
+                    # check below is the authoritative containment barrier.
                     normalised = posixpath.normpath(mapped)
                     if ".." in normalised.split("/"):
                         continue
@@ -170,7 +175,6 @@ def _filter_files_by_target(
                         direct.append(mapped)
                         direct_set.add(mapped)
                         path_mappings[mapped] = f
-                    break
 
     return direct, path_mappings
 

{apm_cli-0.27.0 → apm_cli-0.28.0}/src/apm_cli/commands/_helpers.py

@@ -19,6 +19,7 @@ from ..constants import (
     APM_YML_FILENAME,
     GITIGNORE_FILENAME,
 )
+from ..core import project_name as _project_name
 from ..update_policy import get_update_hint_message, is_self_update_enabled
 from ..utils.atomic_io import (
     atomic_write_text as _atomic_write,  # noqa: F401 -- re-exported; tests import from apm_cli.commands._helpers
@@ -29,6 +30,10 @@ from ..utils.version_checker import check_for_updates
 from ..version import get_build_sha, get_version
 from .deps._utils import _scan_installed_packages
 
+# Thin compatibility aliases only; core/project_name.py remains the AC18 owner.
+_resolve_bootstrap_project_name = _project_name.resolve_bootstrap_project_name
+_validate_project_name = _project_name.validate_project_name
+
 # CRITICAL: Shadow Click commands at module level to prevent namespace collision
 # When Click commands like 'config set' are defined, calling set() can invoke the command
 # instead of the Python built-in. This affects ALL functions in this module.
@@ -617,22 +622,6 @@ def _validate_plugin_name(name):
     return bool(re.match(r"^[a-z][a-z0-9-]{0,63}$", name))
 
 
-def _validate_project_name(name):
-    """Validate that a project name is safe to use as a directory name.
-
-    Project names are used directly as directory names and must not contain
-    '/' or '\' so the name is not interpreted as a filesystem path,
-    and must not be '..' to prevent directory traversal.
-
-    Returns True if valid, False otherwise.
-    """
-    if "/" in name or "\\" in name:
-        return False
-    if name == "..":  # noqa: SIM103
-        return False
-    return True
-
-
 def _create_plugin_json(config):
     """Create plugin.json file with package metadata.
 

{apm_cli-0.27.0 → apm_cli-0.28.0}/src/apm_cli/commands/deps/cli.py

@@ -11,6 +11,7 @@ import click
 # Import existing APM components
 from ...constants import APM_MODULES_DIR, APM_YML_FILENAME, SKILL_MD_FILENAME
 from ...core.command_logger import CommandLogger
+from ...core.project_name import DEFAULT_BOOTSTRAP_PROJECT_NAME
 from ...core.target_detection import TargetParamType
 from ...deps.lockfile import LockedDependency
 from ...models.apm_package import APMPackage
@@ -644,7 +645,7 @@ def _build_dep_tree(apm_dir):
     apm_modules_path = apm_dir / APM_MODULES_DIR
 
     # Load project info
-    project_name = "my-project"
+    project_name = DEFAULT_BOOTSTRAP_PROJECT_NAME
     try:
         apm_yml_path = apm_dir / APM_YML_FILENAME
         if apm_yml_path.exists():

{apm_cli-0.27.0 → apm_cli-0.28.0}/src/apm_cli/commands/init.py

@@ -10,6 +10,10 @@ import click
 from ..bundle.plugin_layout import find_plugin_root_sources
 from ..constants import APM_YML_FILENAME
 from ..core.command_logger import CommandLogger
+from ..core.project_name import (
+    resolve_bootstrap_project_name as _resolve_bootstrap_project_name,
+)
+from ..core.project_name import validate_project_name as _validate_project_name
 from ..core.target_detection import (
     EXPLICIT_ONLY_TARGETS,
     TargetParamType,
@@ -29,7 +33,6 @@ from ._helpers import (
     _get_default_config,
     _rich_blank_line,
     _validate_plugin_name,
-    _validate_project_name,
 )
 
 
@@ -146,10 +149,11 @@ def _perform_init(
             project_name = None
 
         # Reject names containing path separators before any filesystem use
-        if project_name and not _validate_project_name(project_name):
+        if project_name is not None and not _validate_project_name(project_name):
             logger.error(
                 f"Invalid project name '{project_name}': "
-                "project names must not contain path separators ('/' or '\\\\') or be '..'."
+                "project names must not be empty or whitespace-only and must not contain "
+                "path separators ('/' or '\\\\') or be '..'."
             )
             sys.exit(1)
 
@@ -162,7 +166,14 @@ def _perform_init(
             final_project_name = project_name
         else:
             project_dir = Path.cwd()
-            final_project_name = project_dir.name
+            # A filesystem root has no directory name, so resolve a valid fallback.
+            derived_project_name = project_dir.name
+            final_project_name = _resolve_bootstrap_project_name(derived_project_name)
+            if final_project_name != derived_project_name:
+                logger.verbose_detail(
+                    f'Using default project name "{final_project_name}" because '
+                    f"derived name {derived_project_name!a} is invalid"
+                )
         project_root = Path.cwd()
 
         # Validate plugin name early
@@ -395,7 +406,8 @@ def _interactive_project_setup(default_name, logger):
                 break
             console.print(
                 f"[error]Invalid project name '{name}': "
-                "project names must not contain path separators ('/' or '\\\\') or be '..'.[/error]"
+                "project names must not be empty or whitespace-only and must not contain "
+                "path separators ('/' or '\\\\') or be '..'.[/error]"
             )
 
         version = Prompt.ask("Version", default="1.0.0").strip()
@@ -412,7 +424,8 @@ def _interactive_project_setup(default_name, logger):
                 break
             click.echo(
                 f"{ERROR}Invalid project name '{name}': "
-                f"project names must not contain path separators ('/' or '\\\\') or be '..'.{RESET}"
+                f"project names must not be empty or whitespace-only and must not contain "
+                f"path separators ('/' or '\\\\') or be '..'.{RESET}"
             )
 
         version = click.prompt("Version", default="1.0.0").strip()