@primeuicom/mcp 1.2.1 → 1.2.2

package/dist/service.js

@@ -3741,6 +3741,15 @@ var PACKAGE_JSON_RELATIVE_PATH2 = "package.json";
 var VIRTUAL_ROUTE_SEGMENT = "__primeui-component-export";
 var COMPONENT_PAGES_PREFIX = "src/components/pages/";
 var COMPONENT_UI_PREFIX = "src/components/ui/";
+var COMPONENT_SHARED_PREFIX = "src/components/shared/";
+var NATURAL_SUPPORT_PREFIXES = [
+  COMPONENT_UI_PREFIX,
+  "src/lib/",
+  "src/types/",
+  "src/contexts/"
+];
+var PUBLIC_PREFIX = "public/";
+var PUBLIC_ASSET_REFERENCE_RE = /["'`(]\/([^"'`()\s]+\.(?:avif|gif|ico|jpeg|jpg|json|mp4|otf|png|svg|ttf|txt|webm|webmanifest|webp|woff|woff2|xml))(?:\?[^"'`()\s]*)?["'`)]/giu;
 function normalizeComponentId(componentId) {
   const trimmed = componentId.trim();
   if (!trimmed) {
@@ -3773,6 +3782,35 @@ function isVirtualRouteFile(relativePath) {
   const segments = relativePath.split("/");
   return segments[0] === "src" && segments[1] === "app" && segments.includes(VIRTUAL_ROUTE_SEGMENT);
 }
+function getVirtualComponentRelativePath(relativePath, componentId) {
+  const prefix = `${COMPONENT_PAGES_PREFIX}${VIRTUAL_ROUTE_SEGMENT}/${componentId}/`;
+  if (!relativePath.startsWith(prefix)) {
+    return null;
+  }
+  const componentRelativePath = relativePath.slice(prefix.length);
+  return componentRelativePath || null;
+}
+function getComponentPageSourceArea(relativePath) {
+  if (!relativePath.startsWith(COMPONENT_PAGES_PREFIX)) {
+    return null;
+  }
+  const rest = relativePath.slice(COMPONENT_PAGES_PREFIX.length);
+  const slashIndex = rest.indexOf("/");
+  if (slashIndex <= 0) {
+    return null;
+  }
+  const sourceArea = rest.slice(0, slashIndex);
+  return sourceArea === VIRTUAL_ROUTE_SEGMENT ? null : sourceArea;
+}
+function getSourceAreaComponentRelativePath(relativePath, sourceAreas) {
+  const sourceArea = getComponentPageSourceArea(relativePath);
+  if (!sourceArea || !sourceAreas.has(sourceArea)) {
+    return null;
+  }
+  const prefix = `${COMPONENT_PAGES_PREFIX}${sourceArea}/`;
+  const componentRelativePath = relativePath.slice(prefix.length);
+  return componentRelativePath || null;
+}
 function isComponentEntryFile(relativePath, componentId) {
   if (!relativePath.startsWith(COMPONENT_PAGES_PREFIX)) {
     return false;
@@ -3788,7 +3826,155 @@ function isComponentEntryFile(relativePath, componentId) {
   return basename === "index" && path13.basename(path13.dirname(relativePath)) === componentId;
 }
 function isManifestSupportFile(relativePath) {
-  return relativePath.startsWith(COMPONENT_UI_PREFIX);
+  return NATURAL_SUPPORT_PREFIXES.some(
+    (prefix) => relativePath.startsWith(prefix)
+  );
+}
+function isEnvFile(relativePath) {
+  return relativePath === ".env" || relativePath.startsWith(".env.");
+}
+function isSearchRuntimeFile(relativePath) {
+  return relativePath.startsWith("src/app/api/search/") || relativePath.startsWith("src/lib/search/") || relativePath.startsWith("src/lib/search-runtime/") || relativePath.startsWith("src/search/");
+}
+function isProjectLevelFile(relativePath) {
+  return isEnvFile(relativePath) || isSearchRuntimeFile(relativePath) || relativePath.startsWith("scripts/") || relativePath.startsWith("src/app/") || relativePath.startsWith("src/components/header/") || relativePath.startsWith("src/components/footer/") || relativePath.startsWith("src/components/layout/");
+}
+function toComponentSharedTargetPath(componentRelativePath) {
+  return `${COMPONENT_SHARED_PREFIX}${componentRelativePath}`;
+}
+function toImportPath(relativePath) {
+  const withoutExtension = relativePath.replace(/\.[cm]?[jt]sx?$/u, "");
+  const withoutIndex = withoutExtension.replace(/\/index$/u, "");
+  return `@/${withoutIndex.replace(/^src\//u, "")}`;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+}
+function sourceImportSpecifiers(relativePath) {
+  const withAlias = toImportPath(relativePath);
+  const specifiers = [withAlias];
+  if (withAlias.endsWith("/index")) {
+    specifiers.push(withAlias.replace(/\/index$/u, ""));
+  }
+  return [...new Set(specifiers)];
+}
+function rewriteComponentLocalImports(content, transfers) {
+  let updated = content;
+  for (const transfer of transfers) {
+    const targetSpecifier = toImportPath(transfer.targetPath);
+    for (const sourceSpecifier of sourceImportSpecifiers(transfer.sourcePath)) {
+      updated = updated.replace(
+        new RegExp(escapeRegExp(sourceSpecifier), "gu"),
+        targetSpecifier
+      );
+    }
+  }
+  return updated;
+}
+function collectReferencedPublicAssetFiles(content) {
+  const referencedFiles = /* @__PURE__ */ new Set();
+  let match = null;
+  PUBLIC_ASSET_REFERENCE_RE.lastIndex = 0;
+  while ((match = PUBLIC_ASSET_REFERENCE_RE.exec(content)) !== null) {
+    const referencedPath = match[1]?.trim();
+    if (referencedPath) {
+      referencedFiles.add(
+        `${PUBLIC_PREFIX}${normalizeManifestFilePath(referencedPath)}`
+      );
+    }
+  }
+  return [...referencedFiles];
+}
+function findComponentSourceAreas(relativePaths) {
+  const sourceAreas = /* @__PURE__ */ new Set();
+  for (const relativePath of relativePaths) {
+    const sourceArea = getComponentPageSourceArea(relativePath);
+    if (sourceArea) {
+      sourceAreas.add(sourceArea);
+    }
+  }
+  return sourceAreas;
+}
+function getComponentLocalTargetPath(input) {
+  const virtualRelativePath = getVirtualComponentRelativePath(
+    input.relativePath,
+    input.componentId
+  );
+  if (virtualRelativePath) {
+    return toComponentSharedTargetPath(virtualRelativePath);
+  }
+  const sourceAreaRelativePath = getSourceAreaComponentRelativePath(
+    input.relativePath,
+    input.sourceAreas
+  );
+  if (sourceAreaRelativePath) {
+    return toComponentSharedTargetPath(sourceAreaRelativePath);
+  }
+  return null;
+}
+function getTransferTargetPath(input) {
+  if (input.relativePath === PACKAGE_JSON_RELATIVE_PATH2 || isVirtualRouteFile(input.relativePath) || isProjectLevelFile(input.relativePath)) {
+    return null;
+  }
+  const componentLocalTargetPath = getComponentLocalTargetPath(input);
+  if (componentLocalTargetPath) {
+    return componentLocalTargetPath;
+  }
+  if (isManifestSupportFile(input.relativePath)) {
+    return input.relativePath;
+  }
+  if (input.relativePath.startsWith(PUBLIC_PREFIX) && input.referencedPublicFiles.has(input.relativePath)) {
+    return input.relativePath;
+  }
+  return null;
+}
+async function collectReferencedPublicFiles(input) {
+  const referencedPublicFiles = /* @__PURE__ */ new Set();
+  for (const relativePath of input.graphInternalFiles) {
+    if (!input.manifestFileSet.has(relativePath)) {
+      continue;
+    }
+    const sourcePath = path13.join(input.exportPath, relativePath);
+    let content = "";
+    try {
+      content = await readFile7(sourcePath, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const referencedFile of collectReferencedPublicAssetFiles(content)) {
+      if (input.manifestFileSet.has(referencedFile)) {
+        referencedPublicFiles.add(referencedFile);
+      }
+    }
+  }
+  return referencedPublicFiles;
+}
+function buildFileTransfers(input) {
+  const sourceAreas = findComponentSourceAreas([...input.graphInternalFiles]);
+  const transfers = [];
+  const usedTargetPaths = /* @__PURE__ */ new Set();
+  for (const relativePath of input.files) {
+    const isGraphFile = input.graphInternalFiles.has(relativePath);
+    const isReferencedPublicFile = input.referencedPublicFiles.has(relativePath);
+    if (!isGraphFile && !isReferencedPublicFile) {
+      continue;
+    }
+    const targetPath = getTransferTargetPath({
+      relativePath,
+      componentId: input.componentId,
+      sourceAreas,
+      referencedPublicFiles: input.referencedPublicFiles
+    });
+    if (!targetPath || usedTargetPaths.has(targetPath)) {
+      continue;
+    }
+    usedTargetPaths.add(targetPath);
+    transfers.push({
+      sourcePath: relativePath,
+      targetPath
+    });
+  }
+  return transfers.sort((a, b) => a.targetPath.localeCompare(b.targetPath));
 }
 function toSkippedFile(targetPath, reason) {
   return {
@@ -3828,7 +4014,7 @@ function splitManifestFiles(input) {
   };
 }
 async function createConflictReportEntry2(input) {
-  const sourceBuffer = await readFile7(input.sourceFilePath);
+  const sourceBuffer = input.sourceBuffer ?? await readFile7(input.sourceFilePath);
   let targetBuffer = null;
   try {
     targetBuffer = await readFile7(input.targetFilePath);
@@ -3896,7 +4082,7 @@ function buildMessage(input) {
     );
   }
   parts.push(
-    "The virtual component export page was skipped; manually insert the copied component into a real target page."
+    `The virtual component export page was skipped; manually import ${input.componentImportPath} into a real target page.`
   );
   return parts.join(" ");
 }
@@ -3963,23 +4149,37 @@ async function copyRegistryComponentFromExport(input) {
       (filePath) => toProjectRelative(exportPath, filePath)
     )
   );
-  const exportableFileSet = new Set(
-    uniqueNormalizedManifestFiles(getSuccessfulExportableFiles(manifest))
+  const referencedPublicFiles = await collectReferencedPublicFiles({
+    exportPath,
+    graphInternalFiles,
+    manifestFileSet
+  });
+  const fileTransfers = buildFileTransfers({
+    files: initialSelection.manifestFiles,
+    componentId: normalizedComponentId,
+    graphInternalFiles,
+    referencedPublicFiles
+  });
+  const copyableSourceFiles = fileTransfers.map((transfer) => transfer.sourcePath);
+  const copyableFiles = fileTransfers.map((transfer) => transfer.targetPath);
+  const transferBySourcePath = new Map(
+    fileTransfers.map((transfer) => [transfer.sourcePath, transfer])
+  );
+  const componentEntryTransfer = fileTransfers.find(
+    (transfer) => initialSelection.componentEntryFiles.includes(transfer.sourcePath)
+  );
+  const componentImportPath = toImportPath(
+    componentEntryTransfer?.targetPath ?? `${COMPONENT_SHARED_PREFIX}${normalizedComponentId}.tsx`
   );
-  const copyableFiles = initialSelection.manifestFiles.filter(
-    (relativePath) => graphInternalFiles.has(relativePath) || isManifestSupportFile(relativePath) || exportableFileSet.has(relativePath)
-  ).filter(
-    (relativePath) => relativePath !== PACKAGE_JSON_RELATIVE_PATH2 && !isVirtualRouteFile(relativePath)
-  ).sort((a, b) => a.localeCompare(b));
   const { manifestFiles, skippedFiles } = splitManifestFiles({
     files: initialSelection.manifestFiles,
     componentId: normalizedComponentId,
-    copyableFiles
+    copyableFiles: copyableSourceFiles
   });
   const candidateFiles = await resolveManifestCandidateFiles({
     exportPath,
     manifestOwnerLabel: `registry component "${normalizedComponentId}"`,
-    files: copyableFiles,
+    files: copyableSourceFiles,
     requireExisting: false
   });
   for (const sourceFilePath of candidateFiles) {
@@ -3989,9 +4189,21 @@ async function copyRegistryComponentFromExport(input) {
       missingManifestFiles.add(relativeToExport);
       continue;
     }
-    const targetFilePath = path13.join(input.projectRoot, relativeToExport);
+    const transfer = transferBySourcePath.get(relativeToExport);
+    if (!transfer) {
+      continue;
+    }
+    const targetRelativePath = transfer.targetPath;
+    const targetFilePath = path13.join(input.projectRoot, targetRelativePath);
     ensureSafeTargetPath(input.projectRoot, targetFilePath);
     const sourceBuffer = await readFile7(sourceFilePath);
+    const rewrittenSourceBuffer = isBinaryBuffer(sourceBuffer) ? sourceBuffer : Buffer.from(
+      rewriteComponentLocalImports(
+        sourceBuffer.toString("utf-8"),
+        fileTransfers
+      ),
+      "utf-8"
+    );
     let targetBuffer = null;
     try {
       targetBuffer = await readFile7(targetFilePath);
@@ -4000,19 +4212,20 @@ async function copyRegistryComponentFromExport(input) {
     }
     if (!targetBuffer) {
       await ensureDir(path13.dirname(targetFilePath));
-      await writeFile6(targetFilePath, sourceBuffer);
-      newFiles.push(relativeToExport);
+      await writeFile6(targetFilePath, rewrittenSourceBuffer);
+      newFiles.push(targetRelativePath);
       continue;
     }
-    if (sourceBuffer.equals(targetBuffer)) {
-      identicalFiles.push(relativeToExport);
+    if (rewrittenSourceBuffer.equals(targetBuffer)) {
+      identicalFiles.push(targetRelativePath);
       continue;
     }
     const entry = await createConflictReportEntry2({
       sourceFilePath,
       targetFilePath,
       exportPath,
-      projectRoot: input.projectRoot
+      projectRoot: input.projectRoot,
+      sourceBuffer: rewrittenSourceBuffer
     });
     if (entry) {
       conflictReportEntries.push(entry);
@@ -4053,6 +4266,7 @@ async function copyRegistryComponentFromExport(input) {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     exportId,
     componentId: normalizedComponentId,
+    componentImportPath,
     manifestFiles,
     copyableFiles,
     skippedFiles,
@@ -4074,6 +4288,7 @@ async function copyRegistryComponentFromExport(input) {
     status,
     message: buildMessage({
       componentId: normalizedComponentId,
+      componentImportPath,
       status,
       reportPath,
       newFiles: sortedNewFiles,
@@ -4089,6 +4304,7 @@ async function copyRegistryComponentFromExport(input) {
     exportPath,
     manifestPath,
     component: manifest.component,
+    componentImportPath,
     manifestFiles,
     copyableFiles,
     newFiles: sortedNewFiles,
@@ -4111,7 +4327,7 @@ async function copyRegistryComponentFromExport(input) {
     },
     guidance: {
       artifacts: guidanceArtifacts,
-      requiredActions: "Do not install the skipped virtual component export page as a route. Manually import the copied component/support files into a real target page, install newly added dependencies, and resolve any reported conflicts or dependency version mismatches before treating the registry component transfer as complete."
+      requiredActions: `Do not install the skipped virtual component export page as a route. Manually import ${componentImportPath} into a real target page, install newly added dependencies, and resolve any reported conflicts or dependency version mismatches before treating the registry component transfer as complete.`
     }
   };
 }
@@ -5594,10 +5810,12 @@ WHEN TO USE:
 BEHAVIOR:
 - Reads the component sidecar manifest saved by create_component_export.
 - Validates that manifest.component.componentId matches input.componentId.
-- Copies files strictly from page.manifest.files in the component sidecar manifest.
+- Copies only the selected registry component import graph, narrowly referenced public assets, and safe support files from the component sidecar manifest/export.
+- Remaps component-local files into src/components/shared/** and returns componentImportPath for manual insertion.
 - Skips virtual route files that include __primeui-component-export, because those are reference/insertion hints and must not be installed as normal app routes.
+- Skips app/search/layout/header/footer/env/project-shell files instead of copying whole exportable buckets.
 - Never copies package.json directly. package.json is used only to add missing dependency entries and report dependency version conflicts.
-- Preserves export-relative paths for copied files in this first version.
+- Keeps safe support files on their natural target paths, such as src/components/ui/**, src/lib/**, src/types/**, and src/contexts/**.
 - Never overwrites existing conflicting files.
 - Writes full conflict details to .primeui/temp/exports/[exportId].copy-registry-component-report-[copyId].json.
 - Reports copied files, identical files, conflicts, skipped files, dependency additions, dependency version conflicts, missing manifest files, and manual insertion guidance.
@@ -5628,11 +5846,14 @@ ${WORKFLOW_SUMMARY}`,
     component: componentExportComponentSchema.describe(
       "Component metadata from the validated component sidecar manifest."
     ),
+    componentImportPath: z4.string().describe(
+      "Canonical import path for the copied registry component entrypoint, for example @/components/shared/hero--pricing."
+    ),
     manifestFiles: z4.array(z4.string()).describe(
-      "Normalized page.manifest.files from the component sidecar manifest."
+      "Normalized component sidecar manifest files considered by the copy service."
     ),
     copyableFiles: z4.array(z4.string()).describe(
-      "Manifest files considered for copying after filtering virtual route files and package.json."
+      "Relative target paths considered for copying after component remapping and safety filtering."
     ),
     newFiles: z4.array(z4.string()).describe("Relative target paths for new files copied."),
     identicalFiles: z4.array(z4.string()).describe("Relative target paths for existing byte-identical files."),