microsoft/apm

Features

• Command Line Package Managers - Provides a command-line package manager that declares, resolves, locks, and installs agent skills, prompts, instructions, hooks, and MCP servers from git hosts and registries.
• Agent Package Installation - Fetches a resource package and its transitive dependencies in one pass, then deploys files into the directories the chosen tool reads.
• Multi-Source Resource Resolution - Resolves skills, instructions, prompts, and agents from git, local paths, marketplaces, or registries and deploys them into each project's targets.
• Agent Skill Manifests - Declares instructions, skills, prompts, agents, hooks, plugins and servers in one manifest so the same setup installs reproducibly across clients and machines.
• Agent Configuration Management - Declares skills, instructions, prompts, and tool servers in a manifest and installs the identical pinned setup on every machine.
• Agent Client Registrations - Writes one declared configuration into the native formats of many AI coding clients such as Copilot, Claude Code, Cursor and Codex.
• Cross-Harness Config Deployment - Installs one set of declared agent resources into Copilot, Claude Code, Cursor, Windsurf, Codex, Gemini and OpenCode from a single source.
• MCP Server Configurations - Declares and manages Model Context Protocol server settings once and renders them for each agent client.
• Agent Plugin Installations - Installs each declared agent resource with a single command into every supported tool so all developers share the same setup.
• Dependency Lockfiles - Records the exact commit and content hash of every installed package in a lockfile so teammates restore an identical tree after cloning.
• Agent Resource Installers - Resolves declared skills, instructions, and prompts and installs them into a project, with commands to lock, update, and uninstall.
• Frozen Lockfile Installs - Records exact commits, content hashes, and the resolved dependency set so every contributor and CI run installs identical bytes, with frozen mode failing on drift.
• Governance Policies - Applies declarative policy rules with severity levels and merge semantics, letting teams approve or deny specific packages and servers at install time.
• Build Reproducibility Lockfiles - Pins exact commits and content hashes in a lockfile alongside a single manifest so every machine and CI run reproduces the same setup.
• Package Dependency Managers - Declares agent packages in a manifest or via the command line, accepting shorthand, git URLs, monorepo subpaths, files, and local paths with version refs.
• Dependency Governance - Applies allow lists, deny rules, required packages, and trust gates to dependencies at install time and in CI so only approved sources are used.
• Typed Primitive Installations - Copies each skill, agent, and instruction from a package's typed subdirectories into matching runtime directories so consumers can override them individually.
• Dependency Version Locking - Records exact resolved sources and content hashes of installed packages in a lockfile so installs are reproducible and traceable.
• Agent Client Target Matrices - Writes skills, agents, instructions, hooks and tool configuration into the native folders of many AI coding tools, chosen per install or dependency.
• Dependency and Server Policy Governance - Restricts dependencies and MCP servers through allowlists, denylists, required packages, version constraints, transport rules, and depth caps declared in one policy file.
• Hidden Content Scanners - Inspects agent content for tag characters, bidirectional overrides and zero-width characters, flagging critical findings and warnings with distinct exit codes.
• Installation Policies - Applies a policy file restricting allowed sources, scopes and primitives on every install, with tighten-only inheritance from enterprise to organization to repository.
• Tighten-Only Policy Inheritance - Applies a policy file at install time, including to transitive MCP servers, with rules that can only tighten from enterprise to repository.
• Organization Policy Enforcement - Applies organization policy files at install time and in audits, with allow, deny, and required rules plus tighten-only inheritance and deny-wins precedence.
• Agent Primitive Authoring - Defines skills, prompts, instructions, agents, hooks, and tool server configs as files in a package directory that teams can version and share.
• Target Tool Deployment - Deploys resources into the directory layout of a chosen agent tool, set explicitly or detected from marker files in the project.
• Cross-Agent Skill Portability - Lets one resource definition be written once and run unchanged across every supported agent runtime, avoiding vendor lock-in.
• Server Allow and Deny Rules - Controls which MCP servers projects may configure, including whether servers defined in the project's own manifest are allowed, warned about, or denied.
• MCP Server Setups - Records MCP servers in the manifest as registry, self-defined stdio or HTTP, or remote entries, with separate production and dev-only sections.
• Hidden Character Visualizers - Scans deployed prompt and instruction files across project and user scopes for hidden or suspicious Unicode code points that may conceal instructions.
• Agent Package Distribution - Bundles skills, plugins, and prompts into packages and marketplaces that others can install from git hosts or offline archives.
• Agentic Plugin Marketplaces - Packs agent resources into bundles and plugins, publishes marketplaces, shares them offline, and verifies bundle integrity.
• Transitive Server Gates - Pauses installation when a deep dependency declares a new tool server and requires explicit re-declaration in the top-level manifest before it is trusted.
• Lockfile Integrity Validators - Compares deployed files, content hashes, refs, configs and package lists against the lockfile to detect drift, missing files and orphaned packages.
• Package Publishing - Bundles agent resources into packages, plugins, or marketplaces that can be unpacked, previewed, searched, and published for sharing.
• Dependency Resolvers - Walks the full dependency graph beyond top-level entries and picks versions so every package a dependency needs is installed automatically.
• Deterministic Per-Target Compilation - Compiles authored primitives into deterministic per-target output files that produce stable results reviewable with a normal diff.
• Lockfile Consistency Checks - Replays the install in a scratch directory and fails CI when deployed files have drifted, been modified, orphaned or left unrecorded.
• Marketplace Publishing Tools - Writes a marketplace artifact from a declared marketplace block so others can discover and install the package by name.
• Git Host Package Installations - Fetches agent packages from GitHub, GitLab, Bitbucket, Azure DevOps, and other git hosts, resolving transitive dependencies automatically.
• SBOM Generators - Serializes the lockfile into CycloneDX or SPDX bills of materials with component identity, hashes, and licenses, deterministically and offline.
• Project Manifest Configurations - Describes project dependencies and settings in a single manifest file backed by a documented schema covering every supported field.
• Team AI Asset Sharing - Commits the manifest, lockfile, and deployed files to version control so teammates and reviewers get the same agent resources without extra setup.
• CI/CD Policy Gates - Runs policy audits in CI and branch protection, with staged rollout from warnings to blocking across many repositories.
• Plugin & Language Pack Bundling - Bundles agent configuration into a zipped package or standalone plugin and installs plugins from curated marketplaces in one command.
• Offline Agent Resource Bundles - Zips a compiled package into a single archive that can be shipped offline to teams or submitted to a marketplace.
• Lock-File Pinning - Reinstalls strictly from locked pins and rejects missing pins, changed fixed refs, or configuration drift for deterministic builds.
• Banned Dependency Enforcement - Checks every resolved dependency against organization or local allow and deny lists before writing files, blocking packages that are not permitted.
• Dependency Integrity Verifiers - Hashes each downloaded package's file tree, records it in the lockfile, and re-verifies cached content on later installs, aborting on suspected tampering.
• Executable Trust Gates - Blocks unapproved hooks, executables and self-defined servers from dependency packages until approved through organization, project or user trust layers with deny-wins resolution.
• Policy Compliance Audits in CI - Checks the on-disk manifest and lockfile against the discovered policy in CI, failing builds on violations and emitting structured status reports.
• Organization Policy Discovery - Locates the first applicable organization policy from the git remote across GitHub, Azure DevOps and GitLab using conventional repository names and overrides.
• Executable Approval Gates - Blocks hooks, executables, and lifecycle scripts from dependency packages until a user, project, or organization approves them, recording status in the lockfile.
• Software Supply Chain Security - Verifies content hashes, scans for hidden Unicode, detects lockfile drift, and exports CycloneDX or SPDX software bills of materials.
• Configuration Inheritance Policies - Lets policies extend parent policies up to five levels deep, merging so children only tighten rules, and rejects cycles and cross-host extends.
• Software Bill of Materials Generators - Generates CycloneDX or SPDX inventories of installed packages directly from the lockfile for provenance and procurement reviews.
• AI Agent Deployments - Writes one declared set of agent resources into the native folders and formats of many AI coding tools from a single manifest.
• Configuration Drift Checks - Scans deployed agent content for hidden characters, unmanaged files and lockfile drift, and can fail CI when integrity checks do not pass.

Star history