@primeuicom/mcp 1.2.0 → 1.2.2

package/dist/service.js

@@ -3739,6 +3739,17 @@ import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
 import path13 from "path";
 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) {
@@ -3753,38 +3764,257 @@ function normalizeManifestFilePath(filePath) {
   }
   return toPosixPath(trimmed).replace(/^\.\/+/, "");
 }
+function uniqueNormalizedManifestFiles(files) {
+  return [...new Set(files.map(normalizeManifestFilePath))];
+}
+function getSuccessfulExportableFiles(manifest) {
+  return manifest.export.exportables.flatMap(
+    (exportable) => exportable.isReadyToExport && exportable.manifest.success ? exportable.manifest.files : []
+  );
+}
+function getComponentCopyManifestFiles(manifest) {
+  return uniqueNormalizedManifestFiles([
+    ...manifest.page.manifest.files,
+    ...getSuccessfulExportableFiles(manifest)
+  ]);
+}
 function isVirtualRouteFile(relativePath) {
-  return relativePath.split("/").includes(VIRTUAL_ROUTE_SEGMENT);
+  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;
+  }
+  const extension = path13.extname(relativePath);
+  if (!extension) {
+    return false;
+  }
+  const basename = path13.basename(relativePath, extension);
+  if (basename === componentId) {
+    return true;
+  }
+  return basename === "index" && path13.basename(path13.dirname(relativePath)) === componentId;
+}
+function isManifestSupportFile(relativePath) {
+  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 splitManifestFiles(files) {
-  const manifestFiles = files.map(normalizeManifestFilePath);
-  const copyableFiles = [];
+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 {
+    targetPath,
+    reason
+  };
+}
+function splitManifestFiles(input) {
+  const manifestFiles = input.files.map(normalizeManifestFilePath);
+  const copyableFileSet = new Set(input.copyableFiles);
+  const componentEntryFiles = [];
   const skippedFiles = [];
   for (const relativePath of manifestFiles) {
     if (relativePath === PACKAGE_JSON_RELATIVE_PATH2) {
-      skippedFiles.push({
-        targetPath: relativePath,
-        reason: "package_json_managed_as_dependencies"
-      });
+      skippedFiles.push(
+        toSkippedFile(relativePath, "package_json_managed_as_dependencies")
+      );
       continue;
     }
     if (isVirtualRouteFile(relativePath)) {
-      skippedFiles.push({
-        targetPath: relativePath,
-        reason: "virtual_component_route"
-      });
+      skippedFiles.push(toSkippedFile(relativePath, "virtual_component_route"));
       continue;
     }
-    copyableFiles.push(relativePath);
+    if (isComponentEntryFile(relativePath, input.componentId)) {
+      componentEntryFiles.push(relativePath);
+    }
+    if (!copyableFileSet.has(relativePath)) {
+      skippedFiles.push(
+        toSkippedFile(relativePath, "not_component_dependency")
+      );
+    }
   }
   return {
     manifestFiles,
-    copyableFiles,
+    componentEntryFiles,
     skippedFiles
   };
 }
 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);
@@ -3833,7 +4063,7 @@ function buildMessage(input) {
   }
   if (input.skippedFiles.length > 0) {
     parts.push(
-      `${input.skippedFiles.length} manifest file(s) skipped, including virtual route or package metadata entries.`
+      `${input.skippedFiles.length} manifest file(s) skipped, including virtual route, package metadata, or non-component context entries.`
     );
   }
   if (input.missingManifestFiles.length > 0) {
@@ -3852,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(" ");
 }
@@ -3883,13 +4113,16 @@ async function copyRegistryComponentFromExport(input) {
       `Component export manifest mismatch: expected componentId "${normalizedComponentId}", got "${manifest.component.componentId}".`
     );
   }
-  const { manifestFiles, copyableFiles, skippedFiles } = splitManifestFiles(
-    manifest.page.manifest.files
-  );
-  const candidateFiles = await resolveManifestCandidateFiles({
+  const initialSelection = splitManifestFiles({
+    files: getComponentCopyManifestFiles(manifest),
+    componentId: normalizedComponentId,
+    copyableFiles: []
+  });
+  const manifestFileSet = new Set(initialSelection.manifestFiles);
+  const componentEntryCandidates = await resolveManifestCandidateFiles({
     exportPath,
     manifestOwnerLabel: `registry component "${normalizedComponentId}"`,
-    files: copyableFiles,
+    files: initialSelection.componentEntryFiles,
     requireExisting: false
   });
   const newFiles = [];
@@ -3897,7 +4130,58 @@ async function copyRegistryComponentFromExport(input) {
   const conflictFiles = [];
   const conflictReportEntries = [];
   const missingManifestFiles = /* @__PURE__ */ new Set();
-  const existingCandidateFiles = [];
+  const existingComponentEntryFiles = [];
+  for (const sourceFilePath of componentEntryCandidates) {
+    const relativeToExport = toProjectRelative(exportPath, sourceFilePath);
+    if (await fileExists2(sourceFilePath)) {
+      existingComponentEntryFiles.push(sourceFilePath);
+      continue;
+    }
+    missingManifestFiles.add(relativeToExport);
+  }
+  const dependencyGraph = existingComponentEntryFiles.length > 0 ? await buildImportGraph({
+    projectRoot: exportPath,
+    entryFiles: existingComponentEntryFiles,
+    followInternalImports: true
+  }) : { internalFiles: [], externalPackages: [] };
+  const graphInternalFiles = new Set(
+    dependencyGraph.internalFiles.map(
+      (filePath) => toProjectRelative(exportPath, filePath)
+    )
+  );
+  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 { manifestFiles, skippedFiles } = splitManifestFiles({
+    files: initialSelection.manifestFiles,
+    componentId: normalizedComponentId,
+    copyableFiles: copyableSourceFiles
+  });
+  const candidateFiles = await resolveManifestCandidateFiles({
+    exportPath,
+    manifestOwnerLabel: `registry component "${normalizedComponentId}"`,
+    files: copyableSourceFiles,
+    requireExisting: false
+  });
   for (const sourceFilePath of candidateFiles) {
     const relativeToExport = toProjectRelative(exportPath, sourceFilePath);
     const sourceExists = await fileExists2(sourceFilePath);
@@ -3905,10 +4189,21 @@ async function copyRegistryComponentFromExport(input) {
       missingManifestFiles.add(relativeToExport);
       continue;
     }
-    existingCandidateFiles.push(sourceFilePath);
-    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);
@@ -3917,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);
@@ -3939,11 +4235,6 @@ async function copyRegistryComponentFromExport(input) {
       });
     }
   }
-  const dependencyGraph = existingCandidateFiles.length > 0 ? await buildImportGraph({
-    projectRoot: exportPath,
-    entryFiles: existingCandidateFiles,
-    followInternalImports: false
-  }) : { externalPackages: [] };
   const { addedDependencies, dependenciesVersionConflicts } = await applyDependencyRequirementsToPackageJson({
     exportPackageJsonPath: path13.join(exportPath, PACKAGE_JSON_RELATIVE_PATH2),
     userPackageJsonPath: path13.join(
@@ -3975,6 +4266,7 @@ async function copyRegistryComponentFromExport(input) {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     exportId,
     componentId: normalizedComponentId,
+    componentImportPath,
     manifestFiles,
     copyableFiles,
     skippedFiles,
@@ -3996,6 +4288,7 @@ async function copyRegistryComponentFromExport(input) {
     status,
     message: buildMessage({
       componentId: normalizedComponentId,
+      componentImportPath,
       status,
       reportPath,
       newFiles: sortedNewFiles,
@@ -4011,6 +4304,7 @@ async function copyRegistryComponentFromExport(input) {
     exportPath,
     manifestPath,
     component: manifest.component,
+    componentImportPath,
     manifestFiles,
     copyableFiles,
     newFiles: sortedNewFiles,
@@ -4033,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.`
     }
   };
 }
@@ -4853,8 +5147,12 @@ var skippedCopyFileSchema = z4.object({
   targetPath: z4.string().describe(
     "Relative target path intentionally not copied into user project root."
   ),
-  reason: z4.enum(["package_json_managed_as_dependencies", "virtual_component_route"]).describe(
-    "Machine-readable reason for skipping this file. package_json_managed_as_dependencies means package.json was handled as dependency guidance instead of direct file copy. virtual_component_route means the internal component-export route was intentionally not installed into the target app."
+  reason: z4.enum([
+    "package_json_managed_as_dependencies",
+    "virtual_component_route",
+    "not_component_dependency"
+  ]).describe(
+    "Machine-readable reason for skipping this file. package_json_managed_as_dependencies means package.json was handled as dependency guidance instead of direct file copy. virtual_component_route means the internal component-export route was intentionally not installed into the target app. not_component_dependency means the manifest file belongs to page/template context outside the selected registry component dependency set."
   )
 });
 var runtimeGuidanceArtifactSchema = z4.object({
@@ -5512,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.
@@ -5546,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."),