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

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

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

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

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

{apm_cli-0.8.6 → apm_cli-0.8.7}/src/apm_cli/commands/deps/__init__.py

@@ -9,8 +9,6 @@ from ._utils import (
     _get_detailed_context_counts,
     _get_package_display_info,
     _get_detailed_package_info,
-    _update_single_package,
-    _update_all_packages,
 )
 
 __all__ = [
@@ -29,6 +27,4 @@ __all__ = [
     "_get_detailed_context_counts",
     "_get_package_display_info",
     "_get_detailed_package_info",
-    "_update_single_package",
-    "_update_all_packages",
 ]

{apm_cli-0.8.6 → apm_cli-0.8.7}/src/apm_cli/commands/deps/_utils.py

@@ -1,11 +1,10 @@
 """Utility helpers for APM dependency commands."""
 
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict
 
-from ...constants import APM_DIR, APM_MODULES_DIR, APM_YML_FILENAME, SKILL_MD_FILENAME
+from ...constants import APM_DIR, APM_YML_FILENAME, SKILL_MD_FILENAME
 from ...models.apm_package import APMPackage
-from ...deps.github_downloader import GitHubPackageDownloader
 
 
 def _scan_installed_packages(apm_modules_dir: Path) -> list:
@@ -221,106 +220,3 @@ def _get_detailed_package_info(package_path: Path) -> Dict[str, Any]:
             'workflows': 0,
             'hooks': 0
         }
-
-
-def _update_single_package(package_name: str, project_deps: List, apm_modules_path: Path, logger=None):
-    """Update a specific package."""
-    if logger is None:
-        from ...core.command_logger import CommandLogger
-        logger = CommandLogger("deps-update")
-
-    # Find the dependency reference for this package
-    target_dep = None
-    for dep in project_deps:
-        if dep.get_display_name() == package_name or dep.repo_url.split('/')[-1] == package_name:
-            target_dep = dep
-            break
-    
-    if not target_dep:
-        logger.error(f"Package '{package_name}' not found in apm.yml dependencies")
-        return
-    
-    # Find the installed package directory using namespaced structure
-    # GitHub: owner/repo (2 parts)
-    # Azure DevOps: org/project/repo (3 parts)
-    package_dir = None
-    if target_dep.alias:
-        package_dir = apm_modules_path / target_dep.alias
-    else:
-        # Parse path from repo_url
-        repo_parts = target_dep.repo_url.split('/')
-        if target_dep.is_azure_devops() and len(repo_parts) >= 3:
-            # ADO structure: apm_modules/org/project/repo
-            package_dir = apm_modules_path / repo_parts[0] / repo_parts[1] / repo_parts[2]
-        elif len(repo_parts) >= 2:
-            package_dir = apm_modules_path / repo_parts[0] / repo_parts[1]
-        else:
-            # Fallback to simple name matching
-            package_dir = apm_modules_path / package_name
-        
-    if not package_dir.exists():
-        logger.error(f"Package '{package_name}' not installed in apm_modules/")
-        logger.progress(f"Run 'apm install' to install it first")
-        return
-    
-    try:
-        downloader = GitHubPackageDownloader()
-        logger.progress(f"Updating {target_dep.repo_url}...")
-        
-        # Download latest version
-        package_info = downloader.download_package(target_dep, package_dir)
-        
-        logger.success(f"Updated {target_dep.repo_url}")
-        
-    except Exception as e:
-        logger.error(f"Failed to update {package_name}: {e}")
-
-
-def _update_all_packages(project_deps: List, apm_modules_path: Path, logger=None):
-    """Update all packages."""
-    if logger is None:
-        from ...core.command_logger import CommandLogger
-        logger = CommandLogger("deps-update")
-
-    if not project_deps:
-        logger.progress("No APM dependencies to update")
-        return
-        
-    logger.start(f"Updating {len(project_deps)} APM dependencies...")
-    
-    downloader = GitHubPackageDownloader()
-    updated_count = 0
-    
-    for dep in project_deps:
-        # Determine package directory using namespaced structure
-        # GitHub: apm_modules/owner/repo (2 parts)
-        # Azure DevOps: apm_modules/org/project/repo (3 parts)
-        if dep.alias:
-            package_dir = apm_modules_path / dep.alias
-        else:
-            # Parse path from repo_url
-            repo_parts = dep.repo_url.split('/')
-            if dep.is_azure_devops() and len(repo_parts) >= 3:
-                # ADO structure
-                package_dir = apm_modules_path / repo_parts[0] / repo_parts[1] / repo_parts[2]
-            elif len(repo_parts) >= 2:
-                package_dir = apm_modules_path / repo_parts[0] / repo_parts[1]
-            else:
-                # Fallback to simple repo name (shouldn't happen)
-                package_dir = apm_modules_path / dep.repo_url
-            
-        if not package_dir.exists():
-            logger.warning(f"{dep.repo_url} not installed - skipping")
-            continue
-            
-        try:
-            logger.verbose_detail(f"  Updating {dep.repo_url}...")
-            package_info = downloader.download_package(dep, package_dir)
-            updated_count += 1
-            logger.success(f"  {dep.repo_url}")
-            
-        except Exception as e:
-            logger.error(f"  Failed to update {dep.repo_url}: {e}")
-            continue
-    
-    logger.success(f"Updated {updated_count} of {len(project_deps)} packages")

{apm_cli-0.8.6 → apm_cli-0.8.7}/src/apm_cli/commands/deps/cli.py

@@ -11,10 +11,6 @@ from ...constants import APM_DIR, APM_MODULES_DIR, APM_YML_FILENAME, SKILL_MD_FI
 from ...models.apm_package import APMPackage, ValidationResult, validate_apm_package
 from ...core.command_logger import CommandLogger
 
-# Import APM dependency system components (with fallback)
-from ...deps.github_downloader import GitHubPackageDownloader
-from ...deps.apm_resolver import APMDependencyResolver
-
 from ._utils import (
     _is_nested_under_package,
     _count_primitives,
@@ -23,8 +19,6 @@ from ._utils import (
     _get_detailed_context_counts,
     _get_package_display_info,
     _get_detailed_package_info,
-    _update_single_package,
-    _update_all_packages,
 )
 
 
@@ -443,43 +437,188 @@ def clean(dry_run: bool, yes: bool):
         sys.exit(1)
 
 
-@deps.command(help="Update APM dependencies")
-@click.argument('package', required=False)
-def update(package: Optional[str]):
-    """Update specific package or all if no package specified."""
-    logger = CommandLogger("deps-update")
+@deps.command(help="Update APM dependencies to latest refs")
+@click.argument("packages", nargs=-1)
+@click.option("--verbose", "-v", is_flag=True, help="Show detailed update information")
+@click.option(
+    "--force", is_flag=True,
+    help="Overwrite locally-authored files on collision",
+)
+@click.option(
+    "--target", "-t",
+    type=click.Choice(
+        ["copilot", "claude", "cursor", "opencode", "vscode", "agents", "all"],
+        case_sensitive=False,
+    ),
+    default=None,
+    help="Force deployment to a specific target (overrides auto-detection)",
+)
+@click.option(
+    "--parallel-downloads",
+    type=int,
+    default=4,
+    show_default=True,
+    help="Max concurrent package downloads (0 to disable parallelism)",
+)
+def update(packages, verbose, force, target, parallel_downloads):
+    """Update APM dependencies to latest git refs.
+
+    Re-resolves git references (branches/tags) to their current SHAs,
+    downloads updated content, re-integrates primitives, and regenerates
+    the lockfile.
+
+    \b
+    Examples:
+        apm deps update                    # Update all packages
+        apm deps update org/repo           # Update one package
+        apm deps update org/a org/b        # Update specific packages
+        apm deps update --verbose          # Show detailed progress
+    """
+    from ..install import (
+        _install_apm_dependencies,
+        APM_DEPS_AVAILABLE,
+        _APM_IMPORT_ERROR,
+    )
+    from ...core.command_logger import InstallLogger
+    from ...core.auth import AuthResolver
+
+    logger = InstallLogger(verbose=verbose, partial=bool(packages))
+
+    if not APM_DEPS_AVAILABLE:
+        logger.error("APM dependency system not available")
+        if _APM_IMPORT_ERROR:
+            logger.progress(f"Import error: {_APM_IMPORT_ERROR}")
+        sys.exit(1)
+
+    project_root = Path.cwd()
+    apm_yml_path = project_root / APM_YML_FILENAME
+
+    if not apm_yml_path.exists():
+        logger.error(f"No {APM_YML_FILENAME} found in current directory")
+        sys.exit(1)
 
-    project_root = Path(".")
-    apm_modules_path = project_root / APM_MODULES_DIR
-    
-    if not apm_modules_path.exists():
-        logger.progress("No apm_modules/ directory found - no packages to update")
-        return
-    
-    # Get project dependencies to validate updates
     try:
-        apm_yml_path = project_root / APM_YML_FILENAME
-        if not apm_yml_path.exists():
-            logger.error(f"No {APM_YML_FILENAME} found in current directory")
-            return
-            
-        project_package = APMPackage.from_apm_yml(apm_yml_path)
-        project_deps = project_package.get_apm_dependencies()
-        
-        if not project_deps:
-            logger.progress("No APM dependencies defined in apm.yml")
-            return
-            
+        apm_package = APMPackage.from_apm_yml(apm_yml_path)
     except Exception as e:
-        logger.error(f"Error reading {APM_YML_FILENAME}: {e}")
+        logger.error(f"Failed to parse {APM_YML_FILENAME}: {e}")
+        sys.exit(1)
+
+    all_deps = apm_package.get_apm_dependencies() + apm_package.get_dev_apm_dependencies()
+    if not all_deps:
+        logger.progress("No APM dependencies defined in apm.yml")
         return
-    
-    if package:
-        # Update specific package
-        _update_single_package(package, project_deps, apm_modules_path, logger=logger)
+
+    # Validate and normalize requested packages to canonical dependency keys.
+    # The install engine matches only_packages by DependencyReference identity
+    # (e.g. "owner/repo"), so short names like "compliance-rules" must be
+    # mapped to their canonical form before calling the engine.
+    only_pkgs = None
+    if packages:
+        token_to_canonical: Dict[str, str] = {}
+        for dep in all_deps:
+            canonical_key = dep.get_unique_key() or dep.repo_url or dep.get_display_name()
+            tokens = {canonical_key, dep.get_display_name(), dep.repo_url}
+            if hasattr(dep, "alias") and dep.alias:
+                tokens.add(dep.alias)
+            parts = dep.repo_url.split("/")
+            if len(parts) >= 2:
+                tokens.add(parts[-1])
+            for token in tokens:
+                if token and token not in token_to_canonical:
+                    token_to_canonical[token] = canonical_key
+
+        only_pkgs = []
+        seen: Dict[str, bool] = {}
+        for pkg in packages:
+            canonical = token_to_canonical.get(pkg)
+            if not canonical:
+                available = ", ".join(dep.get_display_name() for dep in all_deps)
+                logger.error(f"Package '{pkg}' not found in {APM_YML_FILENAME}")
+                logger.progress(f"Available: {available}")
+                sys.exit(1)
+            if canonical not in seen:
+                seen[canonical] = True
+                only_pkgs.append(canonical)
+
+    # Migrate legacy lockfile first, then snapshot SHAs for before/after diff
+    from ...deps.lockfile import LockFile, get_lockfile_path, migrate_lockfile_if_needed
+
+    lockfile_path = get_lockfile_path(project_root)
+    migrate_lockfile_if_needed(project_root)
+
+    old_lockfile = LockFile.read(lockfile_path)
+    had_baseline = old_lockfile is not None
+    old_shas: dict = {}
+    if old_lockfile:
+        for key, dep in old_lockfile.dependencies.items():
+            old_shas[key] = dep.resolved_commit
+
+    auth_resolver = AuthResolver()
+
+    if packages:
+        noun = f"{len(packages)} package(s)"
+    else:
+        noun = f"all {len(all_deps)} dependencies"
+    logger.start(f"Updating {noun}...")
+
+    try:
+        install_result = _install_apm_dependencies(
+            apm_package,
+            update_refs=True,
+            verbose=verbose,
+            only_packages=only_pkgs,
+            force=force,
+            parallel_downloads=parallel_downloads,
+            logger=logger,
+            auth_resolver=auth_resolver,
+            target=target,
+        )
+    except Exception as e:
+        logger.error(f"Update failed: {e}")
+        if not verbose:
+            logger.progress("Run with --verbose for detailed diagnostics")
+        sys.exit(1)
+
+    # Show diagnostics if any
+    if install_result.diagnostics and install_result.diagnostics.has_diagnostics:
+        install_result.diagnostics.render_summary()
+
+    # Compare old vs new lockfile SHAs to show what changed
+    new_lockfile = LockFile.read(lockfile_path)
+    changed: list = []
+    if new_lockfile:
+        for key, dep in new_lockfile.dependencies.items():
+            old_sha = old_shas.get(key)
+            new_sha = dep.resolved_commit
+            if old_sha and new_sha and old_sha != new_sha:
+                changed.append(
+                    (key, old_sha[:8], new_sha[:8], dep.resolved_ref or "")
+                )
+
+    error_count = 0
+    if install_result.diagnostics:
+        try:
+            error_count = int(install_result.diagnostics.error_count)
+        except (TypeError, ValueError):
+            error_count = 0
+
+    if changed:
+        pkg_noun = "package" if len(changed) == 1 else "packages"
+        if error_count > 0:
+            logger.warning(
+                f"Updated {len(changed)} {pkg_noun} with {error_count} error(s)."
+            )
+        else:
+            logger.success(f"Updated {len(changed)} {pkg_noun}:")
+        for key, old_sha, new_sha, ref in changed:
+            ref_str = f" ({ref})" if ref else ""
+            click.echo(f"  {key}{ref_str}: {old_sha} -> {new_sha}")
+    elif error_count > 0:
+        logger.error(f"Update failed with {error_count} error(s).")
+    elif not had_baseline:
+        logger.success("Update complete.")
     else:
-        # Update all packages
-        _update_all_packages(project_deps, apm_modules_path, logger=logger)
+        logger.success("All packages already at latest refs.")
 
 
 @deps.command(help="Show detailed package information")