@primeuicom/mcp 0.1.10 → 0.1.11

package/dist/service.js

@@ -43,6 +43,36 @@ var exportItemSchema = z.object({
   status: exportStatusSchema,
   createdAt: z.string().describe("Export creation timestamp in ISO-8601 UTC format.")
 }).describe("Single export record from PrimeUI export history.");
+var fileTransferSchema = z.object({
+  sourcePath: z.string().describe("Relative source file path inside downloaded export root."),
+  targetPath: z.string().describe("Relative target file path inside user project root.")
+});
+var conflictFileSchema = fileTransferSchema.extend({
+  diff: z.string().describe(
+    "Unified diff between user file and export file. For binary files the diff contains a plain message."
+  ),
+  isBinary: z.boolean().describe("True if conflict comparison was treated as binary data.")
+});
+var dependencySectionSchema = z.enum([
+  "dependencies",
+  "devDependencies",
+  "peerDependencies"
+]);
+var dependencyToAddSchema = z.object({
+  packageName: z.string().describe("Dependency package name that was missing in user package.json."),
+  version: z.string().describe("Version from exported project's package.json."),
+  section: dependencySectionSchema.describe(
+    "package.json section where dependency should be added."
+  )
+});
+var dependencyVersionConflictSchema = z.object({
+  packageName: z.string().describe("Dependency package name with version mismatch."),
+  section: dependencySectionSchema.describe(
+    "Section where export expects this dependency."
+  ),
+  exportVersion: z.string().describe("Version found in exported project's package.json."),
+  userVersion: z.string().describe("Version currently present in user's package.json.")
+});
 var TRIGGER_PHRASES = [
   "import page from PrimeUI",
   "add page from PrimeUI",
@@ -59,8 +89,8 @@ WORKFLOW ORDER (always follow this sequence):
 2. Reconcile PrimeUI pages with local project pages/routes/paths, then confirm target pages with user
 3. primeui_create_export -> generate export snapshot for agreed pages/analysis scope
 4. primeui_download_export -> download to temp directory
-5. Reconcile downloaded export pages with local files, resolve ambiguities
-6. Move agreed page code + dependencies into user's project and apply integration updates where appropriate
+5. primeui_copy_page -> copy one page safely (repeat for each selected page)
+6. Reconcile integration points and resolve reported conflicts, if any
 7. primeui_clear_temp -> cleanup temp files
 `.trim();
 var initialInstructions = `
@@ -82,16 +112,16 @@ CRITICAL RULES FOR PAGE IMPORT:
 - Before creating export, ask user which pages to add/update (specific pages or all missing pages) and keep that choice in thread context.
 - The downloaded export in .primeui/temp/ contains a full standalone Next.js project.
   Do NOT copy it wholesale.
-- Copy ONLY the target page file and its direct component dependencies.
-- Always use pagePath and componentsPath from tool responses as source of truth for file locations.
-- Trace each page's imports to identify which component folders are needed.
-- Check if components already exist in user's project - merge carefully, don't blindly overwrite.
-- Adjust import paths to match user's project structure.
-- After download/import work, inspect integration points (navigation configs, link menus, route registries, page indexes).
+- Always call primeui_copy_page for each confirmed page instead of manual file copy.
+- primeui_copy_page performs safe copy only:
+  - new files are copied,
+  - identical files are reported,
+  - conflicting files are NEVER overwritten and are returned with diff.
+- primeui_copy_page may add only missing dependencies to user's package.json.
+  It never upgrades existing dependency versions and never runs dependency installation.
+- After page copy operations, inspect integration points (navigation configs, link menus, route registries, page indexes).
 - If integration pattern is obvious, apply it and explicitly mark it in the report with "\u26A0 integration update".
 - If integration pattern is unclear, ask the user before editing integration files.
-- Do NOT copy: package.json, next.config, tailwind.config, layout files, or any project-level config.
-- If merge conflicts arise and cannot be resolved unambiguously, STOP and ask the user to decide.
 `.trim();
 var toolGetProjectInfo = {
   title: "PrimeUI Project Info",
@@ -200,30 +230,19 @@ var toolDownloadExport = {
 
 Do NOT call this as the first step. Requires export ID from primeui_create_export. Start with primeui_get_project_info instead.
 
-WHEN TO USE: Call this AFTER primeui_create_export has returned a completed export. Requires the export ID returned by primeui_create_export (or from primeui_list_exports if the user explicitly requested a previous export).
+WHEN TO USE: Call this AFTER primeui_create_export has returned a completed export. Requires export ID from primeui_create_export so MCP can use the matching local pages snapshot for sidecar manifest generation.
+
+NOTE:
+- Download of an export ID without local pages snapshot may fail.
+- For previous exports, create a fresh export first when possible.
 
 AFTER DOWNLOAD:
-- Reconcile downloaded export pages with the current local project state again.
-- If thread context already defines which pages to add/update and there is no ambiguity, complete the transfer without extra confirmation.
-- If ambiguity remains (especially page/path mismatches), analyze differences in detail and ask direct clarification questions before editing.
-- The response includes pagePath and componentsPath fields. Use these as direct pointers to locate page code and dependencies in export files.
-
-MANUAL IMPORT STEPS per page (do not skip):
-1. Read the page file at the pagePath from the response.
-2. Read the component files at the componentsPath from the response. Trace the page's imports to identify which specific component folders are needed.
-3. Copy ONLY the page file and its component dependencies into the user's project.
-4. Adjust all import paths to match the user's project structure.
-5. Check for existing components in user's project:
-   - If code overlaps or was modified on the user's side, carefully determine the nature of changes on both sides.
-   - If the merge conflict can be resolved unambiguously - resolve it.
-   - If NOT - STOP, explain the conflict to the user, and ask for their decision before continuing.
-6. Inspect integration points used by existing pages (navigation configs, route registries, link components, page indexes).
-7. If integration pattern is obvious and consistent with project conventions, apply integration updates and mark them in the report as "\u26A0 integration update".
-8. If integration pattern is not obvious, provide concrete integration suggestions and ask user confirmation before changing integration files.
-9. Do NOT copy project config files (package.json, next.config, tailwind.config, layout, etc.).
-10. REPEAT steps 1-9 for each page the user wants to import.
-11. Report exactly which files/areas were changed and which items require user follow-up.
-12. Only after ALL pages are successfully imported, call primeui_clear_temp to clean up.
+- Use manifestPath from this response as the contract for page slug/path mapping in copy operations.
+- For each selected page, call primeui_copy_page with:
+  - originPageSlug (required),
+  - actualPageSlug (optional, if route remap is needed).
+- If there are unresolved conflicts in copy report, stop and ask the user.
+- Only after all requested pages are copied and reconciled, call primeui_clear_temp.
 
   ${WORKFLOW_SUMMARY}`,
   inputSchema: {
@@ -238,6 +257,9 @@ MANUAL IMPORT STEPS per page (do not skip):
     projectPath: z.string().describe(
       "Absolute local path to extracted export root in .primeui/temp/exports/[exportId]. Read files from here only."
     ),
+    manifestPath: z.string().describe(
+      "Absolute path to sidecar export manifest file (.primeui/temp/exports/[exportId].manifest.json). primeui_copy_page depends on this file."
+    ),
     pages: z.array(pageSchema).describe(
       "Page descriptors for import decisions. Use pagePath/componentsPath from each item when copying code into user project."
     )
@@ -249,6 +271,77 @@ MANUAL IMPORT STEPS per page (do not skip):
     openWorldHint: true
   }
 };
+var toolCopyPage = {
+  title: "PrimeUI Copy Page",
+  description: `Safely copy one page from downloaded export into the user's local project. Works only with local files in .primeui/temp/exports and does NOT call PrimeUI API.
+
+WHEN TO USE:
+- Call this AFTER primeui_download_export.
+- Call once per selected page.
+- Use actualPageSlug only when user wants to remap route during import.
+
+BEHAVIOR:
+- Reads export sidecar manifest to resolve originPageSlug -> pagePath/componentsPath.
+- Copies page file + full page components folder + recursively discovered internal dependencies.
+- Never overwrites existing conflicting files.
+- Reports:
+  a) copied new files,
+  b) identical existing files,
+  c) conflicting files with diff,
+  d) missing dependencies added to package.json,
+  e) dependency version conflicts (report-only, no auto upgrade).
+- Adds only missing dependencies to package.json (dependencies/devDependencies/peerDependencies).
+- Never updates existing dependency versions and never runs install commands.
+
+${WORKFLOW_SUMMARY}`,
+  inputSchema: {
+    originPageSlug: z.string().describe(
+      "Source page slug from PrimeUI project pages list, for example '/', '/pricing', '/docs'."
+    ),
+    actualPageSlug: z.string().optional().describe(
+      "Optional destination slug in user's project. If omitted, originPageSlug is used."
+    )
+  },
+  outputSchema: {
+    exportId: z.string().describe("Resolved local export identifier used for copy operation."),
+    exportPath: z.string().describe("Absolute path to local extracted export project root."),
+    originPageSlug: z.string().describe("Normalized source page slug requested for copy."),
+    actualPageSlug: z.string().describe("Normalized destination slug used for target route paths."),
+    sourcePagePath: z.string().describe("Source page path relative to export root."),
+    targetPagePath: z.string().describe("Destination page path relative to user project root."),
+    sourceComponentsPath: z.string().describe("Source components directory relative to export root."),
+    targetComponentsPath: z.string().describe(
+      "Destination components directory relative to user project root."
+    ),
+    newFiles: z.array(fileTransferSchema).describe("New files copied into user project without conflicts."),
+    identicalFiles: z.array(fileTransferSchema).describe(
+      "Existing files in user project that are byte-identical to export files."
+    ),
+    conflictFiles: z.array(conflictFileSchema).describe(
+      "Files that already exist and differ from export version. Never overwritten."
+    ),
+    addedDependencies: z.array(dependencyToAddSchema).describe(
+      "Dependencies that were missing and have been added to user's package.json."
+    ),
+    dependenciesVersionConflicts: z.array(dependencyVersionConflictSchema).describe(
+      "Dependencies with version mismatch between export and user project. Report only."
+    ),
+    summary: z.object({
+      totalCandidateFiles: z.number().describe("Total number of candidate files considered for page copy."),
+      copiedFiles: z.number().describe("Number of files copied as new."),
+      identicalFiles: z.number().describe("Number of files detected as identical."),
+      conflictFiles: z.number().describe("Number of conflicting files not copied."),
+      addedDependencies: z.number().describe("Count of dependencies added to package.json."),
+      dependenciesVersionConflicts: z.number().describe("Count of dependency version mismatches reported.")
+    })
+  },
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false
+  }
+};
 var toolClearTemp = {
   title: "PrimeUI Clear Temp",
   description: `Delete all files in .primeui/temp/ and recreate empty temp structure.
@@ -358,11 +451,27 @@ function createPrimeUiMcpServer(source) {
       }
     }
   );
+  server.registerTool(
+    "primeui_copy_page",
+    toolCopyPage,
+    async ({ originPageSlug, actualPageSlug }) => {
+      try {
+        const result = await source.copyPage(
+          originPageSlug,
+          actualPageSlug
+        );
+        return okResult("primeui_copy_page", result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
   return server;
 }
 
 // src/services/project-sync-service.ts
-import path2 from "path";
+import path4 from "path";
+import { readFile as readFile3 } from "fs/promises";
 
 // src/lib/fs.ts
 import { mkdir, rm, writeFile } from "fs/promises";
@@ -389,7 +498,875 @@ async function extractZip(zipPath, targetDir) {
   }
 }
 
+// src/services/page-copy-service.ts
+import { readFile as readFile2, readdir, stat as stat2, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+
+// src/lib/import-graph.ts
+import { readFile, stat } from "fs/promises";
+import { builtinModules } from "module";
+import path2 from "path";
+var INTERNAL_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".json"
+];
+var PARSEABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
+var BUILTIN_MODULES = /* @__PURE__ */ new Set([
+  ...builtinModules,
+  ...builtinModules.map((item) => `node:${item}`)
+]);
+var STATIC_IMPORT_RE = /\bimport\s+(?:type\s+)?(?:[\s\S]*?\sfrom\s+)?["']([^"']+)["']/g;
+var EXPORT_FROM_RE = /\bexport\s+(?:[\s\S]*?\sfrom\s+)["']([^"']+)["']/g;
+var DYNAMIC_IMPORT_RE = /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g;
+var REQUIRE_RE = /\brequire\s*\(\s*["']([^"']+)["']\s*\)/g;
+function collectSpecifiers(content) {
+  const results = /* @__PURE__ */ new Set();
+  let match = null;
+  for (const re of [
+    STATIC_IMPORT_RE,
+    EXPORT_FROM_RE,
+    DYNAMIC_IMPORT_RE,
+    REQUIRE_RE
+  ]) {
+    re.lastIndex = 0;
+    while ((match = re.exec(content)) !== null) {
+      const specifier = match[1]?.trim();
+      if (specifier) {
+        results.add(specifier);
+      }
+    }
+  }
+  return [...results];
+}
+function getExternalPackageName(specifier) {
+  if (!specifier || specifier.startsWith(".") || specifier.startsWith("/")) {
+    return null;
+  }
+  if (specifier.startsWith("node:")) {
+    return null;
+  }
+  if (specifier.startsWith("@/") || specifier.startsWith("@root/")) {
+    return null;
+  }
+  const parts = specifier.split("/");
+  if (parts.length === 0) {
+    return null;
+  }
+  if (specifier.startsWith("@")) {
+    if (parts.length < 2) {
+      return null;
+    }
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0] ?? null;
+}
+async function pathExists(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveFileCandidate(candidateBase) {
+  const ext = path2.extname(candidateBase);
+  if (ext) {
+    if (await pathExists(candidateBase)) {
+      return candidateBase;
+    }
+    return null;
+  }
+  for (const extension of INTERNAL_EXTENSIONS) {
+    const withExtension = `${candidateBase}${extension}`;
+    if (await pathExists(withExtension)) {
+      return withExtension;
+    }
+  }
+  if (await pathExists(candidateBase)) {
+    const stats = await stat(candidateBase);
+    if (stats.isFile()) {
+      return candidateBase;
+    }
+    if (stats.isDirectory()) {
+      for (const extension of INTERNAL_EXTENSIONS) {
+        const indexCandidate = path2.join(candidateBase, `index${extension}`);
+        if (await pathExists(indexCandidate)) {
+          return indexCandidate;
+        }
+      }
+    }
+  }
+  return null;
+}
+async function resolveImportToFile(projectRoot, importerFilePath, specifier) {
+  const externalPackageName = getExternalPackageName(specifier);
+  if (externalPackageName) {
+    if (!BUILTIN_MODULES.has(externalPackageName)) {
+      return {
+        kind: "external",
+        packageName: externalPackageName
+      };
+    }
+    return { kind: "unknown" };
+  }
+  let candidateBase = null;
+  if (specifier.startsWith("@/")) {
+    candidateBase = path2.join(projectRoot, "src", specifier.slice(2));
+  } else if (specifier.startsWith("@root/")) {
+    candidateBase = path2.join(projectRoot, specifier.slice(6));
+  } else if (specifier.startsWith(".")) {
+    candidateBase = path2.resolve(path2.dirname(importerFilePath), specifier);
+  } else if (specifier.startsWith("/")) {
+    candidateBase = path2.join(projectRoot, specifier.slice(1));
+  } else {
+    return { kind: "unknown" };
+  }
+  const resolved = await resolveFileCandidate(candidateBase);
+  if (!resolved) {
+    return { kind: "unknown" };
+  }
+  return {
+    kind: "internal",
+    filePath: resolved
+  };
+}
+function shouldParseFile(filePath) {
+  return PARSEABLE_EXTENSIONS.has(path2.extname(filePath).toLowerCase());
+}
+async function buildImportGraph(input) {
+  const projectRoot = path2.resolve(input.projectRoot);
+  const queue = input.entryFiles.map((filePath) => path2.resolve(filePath));
+  const visited = /* @__PURE__ */ new Set();
+  const internalFiles = /* @__PURE__ */ new Set();
+  const externalPackages = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const currentFilePath = queue.shift();
+    if (!currentFilePath || visited.has(currentFilePath)) {
+      continue;
+    }
+    visited.add(currentFilePath);
+    internalFiles.add(currentFilePath);
+    if (!shouldParseFile(currentFilePath)) {
+      continue;
+    }
+    let content = "";
+    try {
+      content = await readFile(currentFilePath, "utf-8");
+    } catch {
+      continue;
+    }
+    const specifiers = collectSpecifiers(content);
+    for (const specifier of specifiers) {
+      const resolved = await resolveImportToFile(
+        projectRoot,
+        currentFilePath,
+        specifier
+      );
+      if (resolved.kind === "internal") {
+        if (!visited.has(resolved.filePath)) {
+          queue.push(resolved.filePath);
+        }
+        continue;
+      }
+      if (resolved.kind === "external") {
+        externalPackages.add(resolved.packageName);
+      }
+    }
+  }
+  return {
+    internalFiles: [...internalFiles].sort(),
+    externalPackages: [...externalPackages].sort()
+  };
+}
+
+// src/lib/page-paths.ts
+var WEBSITE_APP_ROOT = "src/app/(website)";
+var PAGE_COMPONENTS_ROOT = "src/components/pages";
+var normalizeSlug = (slug) => {
+  const trimmed = slug.trim();
+  if (!trimmed || trimmed === "/") {
+    return "/";
+  }
+  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  const withoutTrailingSlash = withLeadingSlash.replace(/\/+$/, "");
+  return withoutTrailingSlash || "/";
+};
+var slugToFolderPath = (normalizedSlug) => {
+  if (normalizedSlug === "/") {
+    return "";
+  }
+  return normalizedSlug.slice(1);
+};
+var toPathSegment = (value) => {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9/-]+/g, "-");
+  const compact = normalized.replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return compact || "page";
+};
+var buildWebsitePagePath = (normalizedSlug) => {
+  if (normalizedSlug === "/") {
+    return `${WEBSITE_APP_ROOT}/page.tsx`;
+  }
+  return `${WEBSITE_APP_ROOT}${normalizedSlug}/page.tsx`;
+};
+var buildComponentsPath = (folderPath) => `${PAGE_COMPONENTS_ROOT}/${folderPath}`;
+var resolveBlogSectionRoot = (slugFolderPath) => {
+  if (!slugFolderPath) {
+    return "blog";
+  }
+  const segments = slugFolderPath.split("/").filter(Boolean);
+  if (segments.length <= 1) {
+    return "blog";
+  }
+  return segments.slice(0, -1).join("/");
+};
+function resolvePrimeUiPageExportPaths({
+  pageType,
+  slug
+}) {
+  const normalizedSlug = normalizeSlug(slug);
+  const slugFolderPath = slugToFolderPath(normalizedSlug);
+  switch (pageType) {
+    case "landing": {
+      const componentsFolder = slugFolderPath || "home";
+      return {
+        pagePath: buildWebsitePagePath(normalizedSlug),
+        componentsPath: buildComponentsPath(componentsFolder)
+      };
+    }
+    case "pricing":
+    case "contact-us": {
+      const componentsFolder = slugFolderPath || pageType;
+      return {
+        pagePath: buildWebsitePagePath(normalizedSlug),
+        componentsPath: buildComponentsPath(componentsFolder)
+      };
+    }
+    case "docs": {
+      const docsFolder = slugFolderPath || "docs";
+      return {
+        pagePath: `${WEBSITE_APP_ROOT}/${docsFolder}/[[...slug]]/page.tsx`,
+        componentsPath: buildComponentsPath("docs")
+      };
+    }
+    case "blogIndex": {
+      const blogFolder = slugFolderPath || "blog";
+      return {
+        pagePath: `${WEBSITE_APP_ROOT}/${blogFolder}/page.tsx`,
+        componentsPath: buildComponentsPath("blog")
+      };
+    }
+    case "blogPost": {
+      const blogSectionRoot = resolveBlogSectionRoot(slugFolderPath);
+      return {
+        pagePath: `${WEBSITE_APP_ROOT}/${blogSectionRoot}/[slug]/page.tsx`,
+        componentsPath: buildComponentsPath("blog")
+      };
+    }
+    case "legal":
+      return {
+        pagePath: buildWebsitePagePath(normalizedSlug),
+        componentsPath: buildComponentsPath("legal")
+      };
+    default: {
+      const fallbackFolder = slugFolderPath || toPathSegment(pageType);
+      return {
+        pagePath: buildWebsitePagePath(normalizedSlug),
+        componentsPath: buildComponentsPath(fallbackFolder)
+      };
+    }
+  }
+}
+
+// src/lib/text-diff.ts
+var DEFAULT_MAX_DIFF_CHARS = 16e3;
+var MAX_LCS_CELLS = 2e6;
+function computeOps(oldLines, newLines) {
+  const oldLength = oldLines.length;
+  const newLength = newLines.length;
+  const table = Array.from(
+    { length: oldLength + 1 },
+    () => Array(newLength + 1).fill(0)
+  );
+  for (let i2 = oldLength - 1; i2 >= 0; i2 -= 1) {
+    for (let j2 = newLength - 1; j2 >= 0; j2 -= 1) {
+      if (oldLines[i2] === newLines[j2]) {
+        table[i2][j2] = table[i2 + 1][j2 + 1] + 1;
+      } else {
+        table[i2][j2] = Math.max(table[i2 + 1][j2], table[i2][j2 + 1]);
+      }
+    }
+  }
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < oldLength && j < newLength) {
+    if (oldLines[i] === newLines[j]) {
+      ops.push({ kind: "equal", value: oldLines[i] ?? "" });
+      i += 1;
+      j += 1;
+      continue;
+    }
+    if (table[i + 1][j] >= table[i][j + 1]) {
+      ops.push({ kind: "delete", value: oldLines[i] ?? "" });
+      i += 1;
+      continue;
+    }
+    ops.push({ kind: "insert", value: newLines[j] ?? "" });
+    j += 1;
+  }
+  while (i < oldLength) {
+    ops.push({ kind: "delete", value: oldLines[i] ?? "" });
+    i += 1;
+  }
+  while (j < newLength) {
+    ops.push({ kind: "insert", value: newLines[j] ?? "" });
+    j += 1;
+  }
+  return ops;
+}
+function buildUnifiedDiff(input) {
+  const maxChars = input.maxChars ?? DEFAULT_MAX_DIFF_CHARS;
+  if (input.oldText === input.newText) {
+    return "";
+  }
+  const oldLines = input.oldText.split(/\r?\n/);
+  const newLines = input.newText.split(/\r?\n/);
+  const cells = (oldLines.length + 1) * (newLines.length + 1);
+  if (cells > MAX_LCS_CELLS) {
+    return [
+      `--- ${input.oldLabel}`,
+      `+++ ${input.newLabel}`,
+      "@@ diff omitted @@",
+      "Diff is too large to render safely."
+    ].join("\n");
+  }
+  const ops = computeOps(oldLines, newLines);
+  const output = [
+    `--- ${input.oldLabel}`,
+    `+++ ${input.newLabel}`,
+    `@@ -1,${oldLines.length} +1,${newLines.length} @@`
+  ];
+  for (const op of ops) {
+    if (op.kind === "equal") {
+      output.push(` ${op.value}`);
+      continue;
+    }
+    if (op.kind === "delete") {
+      output.push(`-${op.value}`);
+      continue;
+    }
+    output.push(`+${op.value}`);
+  }
+  const diff = output.join("\n");
+  if (diff.length <= maxChars) {
+    return diff;
+  }
+  return `${diff.slice(0, maxChars)}
+... [diff truncated]`;
+}
+
+// src/services/page-copy-service.ts
+var DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies"
+];
+var REWRITABLE_IMPORT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs"
+]);
+function normalizeSlug2(slug) {
+  const trimmed = slug.trim();
+  if (!trimmed || trimmed === "/") {
+    return "/";
+  }
+  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return withLeadingSlash.replace(/\/+$/, "") || "/";
+}
+function toPosixPath(value) {
+  return value.split(path3.sep).join("/");
+}
+function toProjectRelative(rootPath, absolutePath) {
+  return toPosixPath(path3.relative(rootPath, absolutePath));
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isBinaryBuffer(buffer) {
+  const limit = Math.min(buffer.length, 8e3);
+  for (let index = 0; index < limit; index += 1) {
+    if (buffer[index] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
+function stripSrcPrefix(relativePath) {
+  return relativePath.replace(/^src\//, "");
+}
+function buildImportRewritePlan(sourceComponentsPath, targetComponentsPath) {
+  const normalizedSource = toPosixPath(sourceComponentsPath);
+  const normalizedTarget = toPosixPath(targetComponentsPath);
+  if (normalizedSource === normalizedTarget) {
+    return null;
+  }
+  const sourceAtAliasPrefix = `@/${stripSrcPrefix(normalizedSource)}`;
+  const targetAtAliasPrefix = `@/${stripSrcPrefix(normalizedTarget)}`;
+  const sourceRootAliasPrefix = `@root/${normalizedSource}`;
+  const targetRootAliasPrefix = `@root/${normalizedTarget}`;
+  return {
+    sourceAtAliasPrefix,
+    targetAtAliasPrefix,
+    sourceRootAliasPrefix,
+    targetRootAliasPrefix
+  };
+}
+function replaceAliasPrefixInImportStrings(content, sourcePrefix, targetPrefix) {
+  const pattern = new RegExp(
+    `(["'\`])${escapeRegExp(sourcePrefix)}(?=\\/|\\1)`,
+    "g"
+  );
+  return content.replace(pattern, `$1${targetPrefix}`);
+}
+function rewriteImportsForRemappedSlug(content, plan) {
+  const afterAtAlias = replaceAliasPrefixInImportStrings(
+    content,
+    plan.sourceAtAliasPrefix,
+    plan.targetAtAliasPrefix
+  );
+  return replaceAliasPrefixInImportStrings(
+    afterAtAlias,
+    plan.sourceRootAliasPrefix,
+    plan.targetRootAliasPrefix
+  );
+}
+function buildPlannedSourceBuffer(sourceBuffer, sourceFilePath, importRewritePlan) {
+  if (!importRewritePlan) {
+    return sourceBuffer;
+  }
+  const extension = path3.extname(sourceFilePath).toLowerCase();
+  if (!REWRITABLE_IMPORT_EXTENSIONS.has(extension)) {
+    return sourceBuffer;
+  }
+  if (isBinaryBuffer(sourceBuffer)) {
+    return sourceBuffer;
+  }
+  const sourceText = sourceBuffer.toString("utf-8");
+  const rewritten = rewriteImportsForRemappedSlug(sourceText, importRewritePlan);
+  if (rewritten === sourceText) {
+    return sourceBuffer;
+  }
+  return Buffer.from(rewritten, "utf-8");
+}
+async function readJsonFile(filePath) {
+  const content = await readFile2(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function fileExists(filePath) {
+  try {
+    await stat2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isPageRecord(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const maybe = value;
+  return typeof maybe.id === "string" && typeof maybe.title === "string" && typeof maybe.slug === "string" && typeof maybe.pageType === "string" && typeof maybe.isReadyToExport === "boolean" && typeof maybe.pagePath === "string" && typeof maybe.componentsPath === "string";
+}
+function parseManifest(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Invalid export manifest format.");
+  }
+  const maybe = value;
+  if (maybe.schemaVersion !== 1 || typeof maybe.generatedAt !== "string" || typeof maybe.exportId !== "string" || typeof maybe.projectPath !== "string" || !Array.isArray(maybe.pages)) {
+    throw new Error("Export manifest does not match expected schema.");
+  }
+  if (!maybe.pages.every(isPageRecord)) {
+    throw new Error("Export manifest pages payload is invalid.");
+  }
+  return {
+    schemaVersion: 1,
+    generatedAt: maybe.generatedAt,
+    exportId: maybe.exportId,
+    projectPath: maybe.projectPath,
+    pages: maybe.pages
+  };
+}
+async function listFilesRecursively(dirPath) {
+  const files = [];
+  const stack = [dirPath];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) {
+      continue;
+    }
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path3.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+        continue;
+      }
+      if (entry.isFile()) {
+        files.push(absolutePath);
+      }
+    }
+  }
+  return files;
+}
+async function resolveSingleExportDirectory(exportsRoot) {
+  const entries = await readdir(exportsRoot, { withFileTypes: true });
+  const exportDirectories = entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+  if (exportDirectories.length === 0) {
+    throw new Error(
+      "No downloaded exports found in .primeui/temp/exports. Run primeui_download_export first."
+    );
+  }
+  if (exportDirectories.length > 1) {
+    throw new Error(
+      "Multiple export folders found in .primeui/temp/exports. Clear temp with primeui_clear_temp and download one export."
+    );
+  }
+  const exportId = exportDirectories[0] ?? "";
+  return {
+    exportId,
+    exportPath: path3.join(exportsRoot, exportId)
+  };
+}
+function ensureSafeTargetPath(projectRoot, targetPath) {
+  const relative = path3.relative(projectRoot, targetPath);
+  if (relative.startsWith("..") || path3.isAbsolute(relative)) {
+    throw new Error(
+      `Refusing to write outside project root. Computed target: ${targetPath}`
+    );
+  }
+}
+function getDependencyVersion(packageJson, packageName) {
+  for (const section of DEPENDENCY_SECTIONS) {
+    const sectionData = packageJson[section];
+    if (!sectionData || typeof sectionData !== "object") {
+      continue;
+    }
+    const value = sectionData[packageName];
+    if (typeof value === "string") {
+      return {
+        section,
+        version: value
+      };
+    }
+  }
+  return null;
+}
+function getOrCreateDependencySection(packageJson, section) {
+  const existing = packageJson[section];
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    const created = {};
+    packageJson[section] = created;
+    return created;
+  }
+  return existing;
+}
+function sortDependencySections(packageJson) {
+  for (const section of DEPENDENCY_SECTIONS) {
+    const sectionData = packageJson[section];
+    if (!sectionData || typeof sectionData !== "object" || Array.isArray(sectionData)) {
+      continue;
+    }
+    const sorted = Object.fromEntries(
+      Object.entries(sectionData).sort(
+        ([a], [b]) => a.localeCompare(b)
+      )
+    );
+    packageJson[section] = sorted;
+  }
+}
+function resolveTargetFilePath(input) {
+  const {
+    sourceFilePath,
+    sourcePagePath,
+    sourceComponentsPath,
+    targetPagePath,
+    targetComponentsPath,
+    exportRoot,
+    projectRoot
+  } = input;
+  if (sourceFilePath === sourcePagePath) {
+    return targetPagePath;
+  }
+  const componentsPrefix = `${sourceComponentsPath}${path3.sep}`;
+  if (sourceFilePath === sourceComponentsPath || sourceFilePath.startsWith(componentsPrefix)) {
+    const relativeToComponents = path3.relative(
+      sourceComponentsPath,
+      sourceFilePath
+    );
+    return path3.join(targetComponentsPath, relativeToComponents);
+  }
+  const relativeToExport = path3.relative(exportRoot, sourceFilePath);
+  if (relativeToExport.startsWith("..") || path3.isAbsolute(relativeToExport)) {
+    throw new Error(`Source file is outside export root: ${sourceFilePath}`);
+  }
+  return path3.join(projectRoot, relativeToExport);
+}
+async function copyPageFromExport(input) {
+  const normalizedOriginSlug = normalizeSlug2(input.originPageSlug);
+  const normalizedActualSlug = normalizeSlug2(
+    input.actualPageSlug ?? input.originPageSlug
+  );
+  const isSlugRemapped = normalizedActualSlug !== normalizedOriginSlug;
+  const { exportId, exportPath } = await resolveSingleExportDirectory(
+    input.exportsRoot
+  );
+  const manifestPath = path3.join(
+    input.exportsRoot,
+    `${exportId}.manifest.json`
+  );
+  if (!await fileExists(manifestPath)) {
+    throw new Error(
+      `Export manifest is missing at ${manifestPath}. Run primeui_download_export to regenerate it.`
+    );
+  }
+  const manifest = parseManifest(await readJsonFile(manifestPath));
+  if (manifest.exportId !== exportId) {
+    throw new Error(
+      `Manifest exportId mismatch: expected ${exportId}, got ${manifest.exportId}. Re-download export.`
+    );
+  }
+  const page = manifest.pages.find(
+    (item) => normalizeSlug2(item.slug) === normalizedOriginSlug
+  );
+  if (!page) {
+    throw new Error(
+      `Page not found in manifest for slug: ${normalizedOriginSlug}`
+    );
+  }
+  const sourcePagePath = path3.join(exportPath, page.pagePath);
+  const sourceComponentsPath = path3.join(exportPath, page.componentsPath);
+  const sourcePageStats = await stat2(sourcePagePath).catch(() => null);
+  if (!sourcePageStats?.isFile()) {
+    throw new Error(`Source page file not found: ${sourcePagePath}`);
+  }
+  const sourceComponentsStats = await stat2(sourceComponentsPath).catch(
+    () => null
+  );
+  if (!sourceComponentsStats?.isDirectory()) {
+    throw new Error(
+      `Source components folder not found: ${sourceComponentsPath}`
+    );
+  }
+  const targetPaths = normalizedActualSlug === normalizedOriginSlug ? {
+    pagePath: page.pagePath,
+    componentsPath: page.componentsPath
+  } : resolvePrimeUiPageExportPaths({
+    pageType: page.pageType,
+    slug: normalizedActualSlug
+  });
+  const targetPagePath = path3.join(input.projectRoot, targetPaths.pagePath);
+  const targetComponentsPath = path3.join(
+    input.projectRoot,
+    targetPaths.componentsPath
+  );
+  const importRewritePlan = isSlugRemapped ? buildImportRewritePlan(page.componentsPath, targetPaths.componentsPath) : null;
+  ensureSafeTargetPath(input.projectRoot, targetPagePath);
+  ensureSafeTargetPath(input.projectRoot, targetComponentsPath);
+  const componentFiles = await listFilesRecursively(sourceComponentsPath);
+  const seedFiles = [sourcePagePath, ...componentFiles];
+  const importGraph = await buildImportGraph({
+    projectRoot: exportPath,
+    entryFiles: seedFiles
+  });
+  const candidateFiles = [...new Set(importGraph.internalFiles)].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  const newFiles = [];
+  const identicalFiles = [];
+  const conflictFiles = [];
+  for (const sourceFilePath of candidateFiles) {
+    const targetFilePath = resolveTargetFilePath({
+      sourceFilePath,
+      sourcePagePath,
+      sourceComponentsPath,
+      targetPagePath,
+      targetComponentsPath,
+      exportRoot: exportPath,
+      projectRoot: input.projectRoot
+    });
+    ensureSafeTargetPath(input.projectRoot, targetFilePath);
+    const sourceBuffer = await readFile2(sourceFilePath);
+    const plannedSourceBuffer = buildPlannedSourceBuffer(
+      sourceBuffer,
+      sourceFilePath,
+      importRewritePlan
+    );
+    let targetBuffer = null;
+    try {
+      targetBuffer = await readFile2(targetFilePath);
+    } catch {
+      targetBuffer = null;
+    }
+    const sourceRelative = toProjectRelative(exportPath, sourceFilePath);
+    const targetRelative = toProjectRelative(input.projectRoot, targetFilePath);
+    if (!targetBuffer) {
+      await ensureDir(path3.dirname(targetFilePath));
+      await writeFile2(targetFilePath, plannedSourceBuffer);
+      newFiles.push({
+        sourcePath: sourceRelative,
+        targetPath: targetRelative
+      });
+      continue;
+    }
+    if (plannedSourceBuffer.equals(targetBuffer)) {
+      identicalFiles.push({
+        sourcePath: sourceRelative,
+        targetPath: targetRelative
+      });
+      continue;
+    }
+    const isBinary = isBinaryBuffer(plannedSourceBuffer) || isBinaryBuffer(targetBuffer);
+    const diff = isBinary ? "Binary files differ." : buildUnifiedDiff({
+      oldText: targetBuffer.toString("utf-8"),
+      newText: plannedSourceBuffer.toString("utf-8"),
+      oldLabel: `user/${targetRelative}`,
+      newLabel: `export/${sourceRelative}`
+    });
+    conflictFiles.push({
+      sourcePath: sourceRelative,
+      targetPath: targetRelative,
+      diff,
+      isBinary
+    });
+  }
+  const exportPackageJsonPath = path3.join(exportPath, "package.json");
+  const userPackageJsonPath = path3.join(input.projectRoot, "package.json");
+  if (!await fileExists(exportPackageJsonPath)) {
+    throw new Error(`Export package.json not found: ${exportPackageJsonPath}`);
+  }
+  if (!await fileExists(userPackageJsonPath)) {
+    throw new Error(`User package.json not found: ${userPackageJsonPath}`);
+  }
+  const exportPackageJson = await readJsonFile(
+    exportPackageJsonPath
+  );
+  const userPackageJson = await readJsonFile(userPackageJsonPath);
+  const addedDependencies = [];
+  const dependenciesVersionConflicts = [];
+  for (const packageName of importGraph.externalPackages) {
+    const exportDependency = getDependencyVersion(
+      exportPackageJson,
+      packageName
+    );
+    if (!exportDependency) {
+      continue;
+    }
+    const userDependency = getDependencyVersion(userPackageJson, packageName);
+    if (!userDependency) {
+      const sectionData = getOrCreateDependencySection(
+        userPackageJson,
+        exportDependency.section
+      );
+      sectionData[packageName] = exportDependency.version;
+      addedDependencies.push({
+        packageName,
+        version: exportDependency.version,
+        section: exportDependency.section
+      });
+      continue;
+    }
+    if (userDependency.version !== exportDependency.version) {
+      dependenciesVersionConflicts.push({
+        packageName,
+        section: exportDependency.section,
+        exportVersion: exportDependency.version,
+        userVersion: userDependency.version
+      });
+    }
+  }
+  if (addedDependencies.length > 0) {
+    sortDependencySections(userPackageJson);
+    await writeFile2(
+      userPackageJsonPath,
+      `${JSON.stringify(userPackageJson, null, 2)}
+`,
+      "utf-8"
+    );
+  }
+  return {
+    exportId,
+    exportPath,
+    originPageSlug: normalizedOriginSlug,
+    actualPageSlug: normalizedActualSlug,
+    sourcePagePath: page.pagePath,
+    targetPagePath: targetPaths.pagePath,
+    sourceComponentsPath: page.componentsPath,
+    targetComponentsPath: targetPaths.componentsPath,
+    newFiles,
+    identicalFiles,
+    conflictFiles,
+    addedDependencies: addedDependencies.sort(
+      (a, b) => a.packageName.localeCompare(b.packageName)
+    ),
+    dependenciesVersionConflicts: dependenciesVersionConflicts.sort(
+      (a, b) => a.packageName.localeCompare(b.packageName)
+    ),
+    summary: {
+      totalCandidateFiles: candidateFiles.length,
+      copiedFiles: newFiles.length,
+      identicalFiles: identicalFiles.length,
+      conflictFiles: conflictFiles.length,
+      addedDependencies: addedDependencies.length,
+      dependenciesVersionConflicts: dependenciesVersionConflicts.length
+    }
+  };
+}
+
 // src/services/project-sync-service.ts
+function isProjectPage(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const maybe = value;
+  return typeof maybe.id === "string" && typeof maybe.title === "string" && typeof maybe.slug === "string" && typeof maybe.pageType === "string" && typeof maybe.isReadyToExport === "boolean" && typeof maybe.pagePath === "string" && typeof maybe.componentsPath === "string";
+}
+function buildPagesSnapshotPath(exportsRoot, exportId) {
+  return path4.join(exportsRoot, `${exportId}.pages.snapshot.json`);
+}
+function parsePagesSnapshot(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Export pages snapshot is invalid.");
+  }
+  const maybe = value;
+  if (maybe.schemaVersion !== 1 || typeof maybe.generatedAt !== "string" || typeof maybe.exportId !== "string" || !Array.isArray(maybe.pages)) {
+    throw new Error("Export pages snapshot does not match expected schema.");
+  }
+  if (!maybe.pages.every(isProjectPage)) {
+    throw new Error("Export pages snapshot has invalid pages payload.");
+  }
+  return {
+    schemaVersion: 1,
+    generatedAt: maybe.generatedAt,
+    exportId: maybe.exportId,
+    pages: maybe.pages
+  };
+}
 var ProjectSyncService = class {
   provider;
   projectRoot;
@@ -399,9 +1376,9 @@ var ProjectSyncService = class {
   constructor(options) {
     this.projectRoot = options.projectRoot;
     this.provider = options.provider;
-    this.primeUiRoot = path2.join(this.projectRoot, ".primeui");
-    this.tempRoot = path2.join(this.primeUiRoot, "temp");
-    this.exportsRoot = path2.join(this.tempRoot, "exports");
+    this.primeUiRoot = path4.join(this.projectRoot, ".primeui");
+    this.tempRoot = path4.join(this.primeUiRoot, "temp");
+    this.exportsRoot = path4.join(this.tempRoot, "exports");
   }
   async getProjectInfo() {
     await this.ensureTempLayout();
@@ -413,7 +1390,23 @@ var ProjectSyncService = class {
   }
   async createExport() {
     await this.ensureTempLayout();
-    return this.provider.createExport();
+    const result = await this.provider.createExport();
+    const pagesSnapshotPath = buildPagesSnapshotPath(
+      this.exportsRoot,
+      result.export.id
+    );
+    const snapshot = {
+      schemaVersion: 1,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exportId: result.export.id,
+      pages: result.pages
+    };
+    await writeUtf8(
+      pagesSnapshotPath,
+      `${JSON.stringify(snapshot, null, 2)}
+`
+    );
+    return result;
   }
   async downloadExportById(id) {
     await this.ensureTempLayout();
@@ -422,36 +1415,74 @@ var ProjectSyncService = class {
     if (!selected) {
       throw new Error(`Export not found: ${id}`);
     }
-    const targetZipPath = path2.join(this.exportsRoot, `${id}.zip`);
-    const targetProjectPath = path2.join(this.exportsRoot, id);
+    const targetZipPath = path4.join(this.exportsRoot, `${id}.zip`);
+    const targetProjectPath = path4.join(this.exportsRoot, id);
     await ensureDir(this.exportsRoot);
     await this.provider.downloadExportArchive(id, targetZipPath);
     await resetDir(targetProjectPath);
     await extractZip(targetZipPath, targetProjectPath);
-    const { pages } = await this.provider.getProjectInfo();
+    const pagesSnapshotPath = buildPagesSnapshotPath(this.exportsRoot, id);
+    let pagesSnapshot;
+    try {
+      const snapshotRaw = JSON.parse(
+        await readFile3(pagesSnapshotPath, "utf-8")
+      );
+      pagesSnapshot = parsePagesSnapshot(snapshotRaw);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Export pages snapshot is required for download id "${id}". Run primeui_create_export for this export before downloading. Details: ${reason}`
+      );
+    }
+    if (pagesSnapshot.exportId !== id) {
+      throw new Error(
+        `Export pages snapshot mismatch for id "${id}". Run primeui_create_export and retry download.`
+      );
+    }
+    const pages = pagesSnapshot.pages;
+    const manifestPath = path4.join(this.exportsRoot, `${id}.manifest.json`);
+    const manifest = {
+      schemaVersion: 1,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exportId: id,
+      projectPath: targetProjectPath,
+      pages
+    };
+    await writeUtf8(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`);
     return {
       exportId: id,
       projectPath: targetProjectPath,
+      manifestPath,
       pages
     };
   }
+  async copyPage(originPageSlug, actualPageSlug) {
+    await this.ensureTempLayout();
+    return copyPageFromExport({
+      projectRoot: this.projectRoot,
+      exportsRoot: this.exportsRoot,
+      originPageSlug,
+      actualPageSlug
+    });
+  }
   async clearTemp() {
     await resetDir(this.tempRoot);
-    await writeUtf8(path2.join(this.tempRoot, ".gitkeep"), "");
+    await writeUtf8(path4.join(this.tempRoot, ".gitkeep"), "");
     await ensureDir(this.exportsRoot);
   }
   async ensureTempLayout() {
     await ensureDir(this.primeUiRoot);
     await ensureDir(this.tempRoot);
     await ensureDir(this.exportsRoot);
-    await writeUtf8(path2.join(this.tempRoot, ".gitkeep"), "");
+    await writeUtf8(path4.join(this.tempRoot, ".gitkeep"), "");
   }
 };
 
 // src/sources/api-provider.ts
 import { createWriteStream } from "fs";
 import { unlink } from "fs/promises";
-import path3 from "path";
+import path5 from "path";
 import { Readable, Transform } from "stream";
 import { pipeline } from "stream/promises";
 import { z as z2 } from "zod";
@@ -620,7 +1651,7 @@ var ApiProjectDataProvider = class {
     if (!response.body) {
       throw new PrimeUiApiContractError(endpoint, "response body is empty");
     }
-    await ensureDir(path3.dirname(destinationPath));
+    await ensureDir(path5.dirname(destinationPath));
     const zipStream = Readable.fromWeb(
       response.body
     );