boolean localProject;

            try {
                ArtifactCoordinates coordinates = session.createArtifactCoordinates(session.getArtifact(pomArtifact));
                // Use provided repositories if available, otherwise fall back to request repositories
                ArtifactResolverRequest req = ArtifactResolverRequest.builder()

        requireNonNull(project, "project" + " cannot be null");
        Collection<ProducedArtifact> attached =
                map(getMavenProject(project).getAttachedArtifacts(), a -> getSession(project)
                        .getArtifact(ProducedArtifact.class, RepositoryUtils.toArtifact(a)));
        return Collections.unmodifiableCollection(attached);
    }

    @Override
    @Nonnull

                ArtifactRequest request = new ArtifactRequest(pomArtifact, repositories, context);
                request.setTrace(trace);
                pomArtifact = resolver.resolveArtifact(session, request).getArtifact();
            } catch (ArtifactResolutionException e) {
                throw new UnresolvableModelException(e.getMessage(), groupId, artifactId, version, e);
            }

            return result.getArtifactResults().stream()
                    .filter(ArtifactResult::isResolved)
                    .map(ArtifactResult::getArtifact)
                    .collect(Collectors.toList());
        } catch (PluginResolutionException | InterpolatorException e) {
            throw new ExtensionResolutionException(extension, e);
        }
    }

        return item;
    }

    private Artifact getArtifactFromInstallForm(final InstallForm form) {
        final String[] values = form.id.split(":");
        return ComponentUtil.getPluginHelper().getArtifact(values[0], values[1]);
    }

    /**
     * Installs the specified artifact in a background thread.
     * Also removes any previously installed versions of the same plugin.
     *

            return result.getArtifactResults().stream()
                    .filter(ArtifactResult::isResolved)
                    .map(ArtifactResult::getArtifact)
                    .collect(Collectors.toList());
        } catch (PluginResolutionException | InterpolatorException e) {
            throw new ExtensionResolutionException(extension, e);
        }
    }

        if (dependency == null) {
            return null;
        }

        org.apache.maven.artifact.Artifact result = toArtifact(dependency.getArtifact());
        result.setScope(dependency.getScope());
        result.setOptional(dependency.isOptional());

        return result;
    }

                        Stream.of(new ProjectArtifact(project)),
                        // main project artifact if not a pom
                        "pom".equals(project.getPackaging()) ? Stream.empty() : Stream.of(project.getArtifact())),
                // attached artifacts
                project.getAttachedArtifacts().stream());
        return artifacts.map(RepositoryUtils::toArtifact);
    }

     *
     * @param name the name of the artifact
     * @param version the version of the artifact
     * @return the artifact if found, null otherwise
     */
    public Artifact getArtifact(final String name, final String version) {
        if (StringUtil.isBlank(name) || StringUtil.isBlank(version)) {
            return null;
        }

                return new PluginRealmCache.CacheRecord(
                        pluginDescriptor.getClassRealm(), pluginDescriptor.getArtifacts());
            });

            pluginDescriptor.setClassRealm(cacheRecord.getRealm());
            pluginDescriptor.setArtifacts(new ArrayList<>(cacheRecord.getArtifacts()));
            for (ComponentDescriptor<?> componentDescriptor : pluginDescriptor.getComponents()) {