@openvue/migrate 0.0.1-alpha.2

package/LICENSE.md

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-2025 PrimeTek
+Copyright (c) 2026 OpenVue Foundation and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# @openvue/migrate
+
+Codemod that migrates a PrimeVue project to [OpenVue](https://github.com/openvi-foundation/openvue). OpenVue keeps PrimeVue's public API unchanged (`usePrimeVue`, `PrimeVueResolver`, the `primevue` Nuxt config key, `p-` CSS classes, pass-through options), so migrating is a package rename — which is exactly and only what this tool does.
+
+## Usage
+
+One command, from the root of your project (for monorepos, run it at the workspace root so overrides land in the right place):
+
+```sh
+npx @openvue/migrate
+```
+
+It rewrites dependencies and source files, then runs your package manager's install (detected from the lockfile) so the migrated project builds immediately.
+
+**Already installed OpenVue yourself?** If `openvue` is found in your `package.json` or `node_modules`, the tool switches to sources-only mode: dependencies and `node_modules` are left completely untouched, no install runs, and only source-file imports are rewritten.
+
+| Option         | Description                                              |
+| -------------- | -------------------------------------------------------- |
+| `[dir]`        | Directory to migrate (defaults to the current directory) |
+| `--dry`        | Report what would change without writing any files       |
+| `--no-install` | Skip the package manager install after rewriting         |
+| `--no-alias`   | Do not add the `primevue` -> `openvue` override          |
+| `--force`      | Run even if the git working tree has uncommitted changes |
+
+The tool refuses to run on a dirty git tree by default, so the migration is always a single reviewable, revertible diff.
+
+## What it does
+
+1. **Renames dependencies** in every `package.json` (monorepos supported): `dependencies`, `devDependencies`, `peerDependencies`, `optionalDependencies`, `peerDependenciesMeta`, `resolutions`, `overrides` and `pnpm.overrides`, including selector keys like `**/primevue` or `primevue@^4`. `workspace:`/`catalog:`/`npm:` protocol values are preserved, and `pnpm-workspace.yaml` catalogs are rewritten too. If both `primevue` and `openvue` entries exist, yours wins and the leftover is removed.
+2. **Rewrites module specifiers** in `.js`, `.mjs`, `.cjs`, `.ts`, `.mts`, `.cts`, `.jsx`, `.tsx`, `.vue`, `.astro` and `.mdx` files — static imports, `import type`, `require()`, dynamic `import()`, Nuxt `modules` arrays, Vite `optimizeDeps`/`transpile` entries, and generated `components.d.ts` files. Subpath (`primevue/button`) and scoped (`@primevue/*`) specifiers are unambiguous and rewritten anywhere; a bare `'primevue'` string is only rewritten in import positions (or anywhere in `*.config.*` files), so runtime data like `provider: 'primevue'` is never touched.
+3. **Adds a compatibility override** (`"primevue": "npm:openvue@<version>"` — in `overrides`, `pnpm.overrides` or `resolutions` depending on your package manager) so third-party libraries that depend or peer-depend on `primevue` resolve to OpenVue. Remove it once your whole dependency graph is OpenVue-native, or skip it with `--no-alias`.
+4. **Audits what's left**: after rewriting, it scans sources, styles, HTML and tsconfig files for surviving PrimeVue references (interpolated `import(\`primevue/${name}\`)`, CSS `@import`s, CDN urls, tsconfig `paths`) and lists each one with file and line, so it never reports success while actionable references remain.
+
+The rename mapping:
+
+| From                                                                                                                                                                         | To                            |
+| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------- |
+| `primevue`, `primevue/*`                                                                                                                                                     | `openvue`, `openvue/*`        |
+| `@primevue/core`, `@primevue/forms`, `@primevue/icons`, `@primevue/themes`, `@primevue/nuxt-module`, `@primevue/auto-import-resolver`, `@primevue/metadata`, `@primevue/mcp` | same names under `@openvue/*` |
+
+Left untouched on purpose — OpenVue still uses these upstream packages: `@primeuix/*`, `primeicons`, `primeflex`, `tailwindcss-primeui`. The `primevue` Nuxt config key also stays, because OpenVue's Nuxt module kept it.
+
+Renamed dependencies are pinned to the exact OpenVue version while OpenVue is in alpha; once stable releases start, the codemod will emit caret ranges instead.
+
+## Try OpenVue without changing any code
+
+If you just want to evaluate OpenVue first, add only the override yourself instead of running the codemod — no source changes needed:
+
+```jsonc
+// package.json (npm / bun; use pnpm.overrides for pnpm, resolutions for yarn)
+{
+    "overrides": {
+        "primevue": "npm:openvue@0.0.1-alpha.1"
+    }
+}
+```
+
+Once you decide to stay, run `npx @openvue/migrate` for the real rename.
+
+## Requirements
+
+- Node.js 18+
+- Your project should be on PrimeVue 4.x (the fork point). Coming from v3 or earlier, apply the [PrimeVue v4 migration guide](https://primevue.org/guides/migration/v4/) as well — this tool warns you if it detects a pre-4.x version.

package/dist/index.d.ts

@@ -0,0 +1,107 @@
+declare const OPENVUE_VERSION: string;
+/**
+ * Maps a PrimeVue module specifier or package name to its OpenVue equivalent.
+ * Returns null when the specifier is not a PrimeVue package (or not one that exists in OpenVue).
+ */
+declare function renameSpecifier(specifier: string): string | null;
+
+interface SourceRewriteOptions {
+    configFile?: boolean;
+}
+interface SourceRewriteResult {
+    code: string;
+    count: number;
+    skippedKeys: string[];
+    unknownScoped: string[];
+}
+/**
+ * Rewrites PrimeVue module specifiers inside string literals of a source file (.js/.ts/.vue/...).
+ * Subpath (`primevue/x`) and scoped (`@primevue/x`) specifiers are unambiguous and rewritten in any
+ * position — this also covers require(), dynamic import(), Nuxt `modules` arrays and Vite config
+ * entries. A bare `primevue` literal is only rewritten in import context (or anywhere in config
+ * files), so runtime data like `provider: 'primevue'` is never touched in application code.
+ */
+declare function rewriteSource(code: string, options?: SourceRewriteOptions): SourceRewriteResult;
+interface PackageJsonRewriteResult {
+    text: string;
+    changed: boolean;
+    renamed: string[];
+    notes: string[];
+    unknownScoped: string[];
+    oldPrimevueRange: string | null;
+}
+/**
+ * Rewrites PrimeVue dependency entries in a package.json, preserving key order,
+ * indentation style and any workspace:/catalog:/npm: protocol values.
+ */
+declare function rewritePackageJson(text: string): PackageJsonRewriteResult;
+type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+interface AliasRewriteResult {
+    text: string;
+    added: boolean;
+}
+/**
+ * Adds a package-manager override aliasing `primevue` to `openvue`, so third-party libraries that
+ * depend on or peer-depend on `primevue` resolve to OpenVue after the migration. Without this,
+ * rename-only migration breaks any project whose dependency graph references PrimeVue transitively.
+ */
+declare function addCompatAlias(text: string, packageManager: PackageManager): AliasRewriteResult;
+interface YamlRewriteResult {
+    text: string;
+    count: number;
+}
+/**
+ * Rewrites PrimeVue entries in pnpm-workspace.yaml (catalog/catalogs/overrides sections).
+ */
+declare function rewriteWorkspaceYaml(text: string): YamlRewriteResult;
+
+type MigrateMode = 'full' | 'sources-only';
+interface MigrateOptions {
+    dir: string;
+    dry?: boolean;
+    alias?: boolean;
+}
+interface ChangedFile {
+    file: string;
+    changes: number;
+    renamed?: string[];
+}
+interface ResidualReference {
+    file: string;
+    line: number;
+    text: string;
+}
+interface MigrateResult {
+    mode: MigrateMode;
+    changedFiles: ChangedFile[];
+    warnings: string[];
+    notes: string[];
+    residuals: ResidualReference[];
+    failed: boolean;
+    oldPrimevueRange: string | null;
+    packageManager: PackageManager;
+    installCommand: string;
+}
+/**
+ * A project that already declares or installed OpenVue has handled the dependency switch itself —
+ * the migration then only rewrites source files and must not touch package.json or node_modules.
+ */
+declare function hasOpenVue(dir: string): boolean;
+/**
+ * Detects the package manager from lockfiles or the packageManager field, walking up parent
+ * directories so running from a workspace package still reports the monorepo's real manager.
+ */
+declare function detectPackageManager(dir: string): PackageManager;
+/**
+ * Scans for PrimeVue references that survived the rewrite (interpolated template literals, CSS
+ * imports, tsconfig paths, CDN urls, intentionally kept keys) so the CLI never reports success
+ * while actionable references remain.
+ */
+declare function auditResiduals(dir: string, files: string[]): ResidualReference[];
+/**
+ * Runs the PrimeVue -> OpenVue migration over a project directory.
+ * Pure file transformation — git preflight, install and console output live in the CLI.
+ */
+declare function migrate(options: MigrateOptions): MigrateResult;
+
+export { type ChangedFile, type MigrateMode, type MigrateOptions, type MigrateResult, OPENVUE_VERSION, type ResidualReference, addCompatAlias, auditResiduals, detectPackageManager, hasOpenVue, migrate, renameSpecifier, rewritePackageJson, rewriteSource, rewriteWorkspaceYaml };

package/dist/index.js

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync2, realpathSync, statSync } from "fs";
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/mappings.ts
+import { readFileSync } from "fs";
+var OPENVUE_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+var SCOPED_PACKAGES = ["core", "forms", "icons", "themes", "nuxt-module", "auto-import-resolver", "metadata", "mcp"];
+function renameSpecifier(specifier) {
+  if (specifier === "primevue") return "openvue";
+  if (specifier.startsWith("primevue/")) return "openvue" + specifier.slice("primevue".length);
+  if (specifier.startsWith("@primevue/")) {
+    const rest = specifier.slice("@primevue/".length);
+    const name = rest.split("/")[0];
+    if (SCOPED_PACKAGES.includes(name)) return "@openvue/" + rest;
+  }
+  return null;
+}
+function isUnknownScopedPackage(specifier) {
+  return specifier.startsWith("@primevue/") && renameSpecifier(specifier) === null;
+}
+
+// src/migrate.ts
+import { existsSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { basename, dirname, extname, join as join2, relative } from "path";
+
+// src/rewrite.ts
+var STRING_LITERAL = /(['"`])((?:\\.|(?!\1)[^\\\r\n])*)\1/g;
+var IMPORT_CONTEXT = /(?:\bfrom|\bimport)\s*$|(?:\bimport|\brequire)\s*\(\s*$/;
+var VALUE_PROTOCOL = /^(workspace:|catalog:|npm:|file:|link:|portal:|git|https?:)/;
+function rewriteSource(code, options = {}) {
+  let out = "";
+  let last = 0;
+  let count = 0;
+  const skippedKeys = [];
+  const unknownScoped = [];
+  let match;
+  STRING_LITERAL.lastIndex = 0;
+  while ((match = STRING_LITERAL.exec(code)) !== null) {
+    const [literal, quote, content] = match;
+    if (quote === "`" && content.includes("${")) continue;
+    const renamed = renameSpecifier(content);
+    if (renamed === null) {
+      if (isUnknownScopedPackage(content)) unknownScoped.push(content);
+      continue;
+    }
+    if (content === "primevue") {
+      if (/^\s*:/.test(code.slice(match.index + literal.length))) {
+        skippedKeys.push(content);
+        continue;
+      }
+      const preceding = code.slice(Math.max(0, match.index - 40), match.index);
+      if (!options.configFile && !IMPORT_CONTEXT.test(preceding)) continue;
+    }
+    out += code.slice(last, match.index) + quote + renamed + quote;
+    last = match.index + literal.length;
+    count++;
+  }
+  return { code: out + code.slice(last), count, skippedKeys, unknownScoped };
+}
+var DEPENDENCY_SECTIONS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies", "peerDependenciesMeta", "resolutions", "overrides"];
+function renameDependencyKey(key) {
+  const direct = renameSpecifier(key);
+  if (direct !== null) return direct;
+  const selector = /^(.+)@([^@]+)$/.exec(key);
+  if (selector !== null && renameSpecifier(selector[1]) !== null) return renameSpecifier(selector[1]);
+  const path = /^(.*\/)(primevue|@primevue\/.+)$/.exec(key);
+  if (path !== null && renameSpecifier(path[2]) !== null) return path[1] + renameSpecifier(path[2]);
+  return null;
+}
+function renameDependencies(deps, result) {
+  const next = {};
+  let changed = false;
+  for (const [key, value] of Object.entries(deps)) {
+    const renamedKey = renameDependencyKey(key) ?? key;
+    let nextValue = value;
+    if (renamedKey !== key) {
+      if (Object.prototype.hasOwnProperty.call(deps, renamedKey)) {
+        result.notes.push(`kept existing ${renamedKey} entry and removed ${key}`);
+        changed = true;
+        continue;
+      }
+      changed = true;
+      result.renamed.push(`${key} -> ${renamedKey}`);
+    } else if (isUnknownScopedPackage(key)) {
+      result.unknownScoped.push(key);
+    }
+    if (value !== null && typeof value === "object") {
+      const child = renameDependencies(value, result);
+      nextValue = child.next;
+      changed = changed || child.changed;
+    } else if (renamedKey !== key && typeof value === "string" && !VALUE_PROTOCOL.test(value)) {
+      nextValue = OPENVUE_VERSION;
+    }
+    next[renamedKey] = nextValue;
+  }
+  return { next, changed };
+}
+function serializePackageJson(pkg, originalText) {
+  const indent = /\n([ \t]+)"/.exec(originalText)?.[1] ?? "  ";
+  const newline = originalText.endsWith("\n") ? "\n" : "";
+  return JSON.stringify(pkg, null, indent) + newline;
+}
+function rewritePackageJson(text) {
+  const pkg = JSON.parse(text);
+  const result = { renamed: [], notes: [], unknownScoped: [] };
+  let changed = false;
+  let oldPrimevueRange = null;
+  for (const section of DEPENDENCY_SECTIONS) {
+    const deps = pkg[section];
+    if (deps === null || typeof deps !== "object") continue;
+    if (typeof deps["primevue"] === "string" && oldPrimevueRange === null) oldPrimevueRange = deps["primevue"];
+    const renamed = renameDependencies(deps, result);
+    pkg[section] = renamed.next;
+    changed = changed || renamed.changed;
+  }
+  if (pkg.pnpm && pkg.pnpm.overrides && typeof pkg.pnpm.overrides === "object") {
+    const renamed = renameDependencies(pkg.pnpm.overrides, result);
+    pkg.pnpm.overrides = renamed.next;
+    changed = changed || renamed.changed;
+  }
+  if (!changed) return { text, changed: false, ...result, oldPrimevueRange };
+  return { text: serializePackageJson(pkg, text), changed: true, ...result, oldPrimevueRange };
+}
+function addCompatAlias(text, packageManager) {
+  const pkg = JSON.parse(text);
+  const alias = `npm:openvue@${OPENVUE_VERSION}`;
+  if (packageManager === "yarn") {
+    pkg.resolutions = pkg.resolutions ?? {};
+    if (pkg.resolutions["primevue"] !== void 0) return { text, added: false };
+    pkg.resolutions["primevue"] = alias;
+  } else if (packageManager === "pnpm") {
+    pkg.pnpm = pkg.pnpm ?? {};
+    pkg.pnpm.overrides = pkg.pnpm.overrides ?? {};
+    if (pkg.pnpm.overrides["primevue"] !== void 0) return { text, added: false };
+    pkg.pnpm.overrides["primevue"] = alias;
+  } else {
+    pkg.overrides = pkg.overrides ?? {};
+    if (pkg.overrides["primevue"] !== void 0) return { text, added: false };
+    pkg.overrides["primevue"] = alias;
+  }
+  return { text: serializePackageJson(pkg, text), added: true };
+}
+var YAML_DEPENDENCY_LINE = /^(\s*)(['"]?)(primevue|@primevue\/[a-z0-9-]+)\2(\s*:\s*)(\S.*?)(\s*)$/;
+function rewriteWorkspaceYaml(text) {
+  let count = 0;
+  const lines = text.split("\n").map((line) => {
+    const match = YAML_DEPENDENCY_LINE.exec(line);
+    if (match === null) return line;
+    const [, indent, quote, name, separator, value, trailing] = match;
+    const renamed = renameSpecifier(name);
+    if (renamed === null) return line;
+    const nextValue = VALUE_PROTOCOL.test(value) ? value : OPENVUE_VERSION;
+    count++;
+    return `${indent}${quote}${renamed}${quote}${separator}${nextValue}${trailing}`;
+  });
+  return { text: lines.join("\n"), count };
+}
+
+// src/walk.ts
+import { readdirSync } from "fs";
+import { join } from "path";
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "coverage", ".git", ".nuxt", ".output", ".next", ".vite", ".cache", ".turbo"]);
+function walk(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (!EXCLUDED_DIRS.has(entry.name)) files.push(...walk(join(dir, entry.name)));
+    } else if (entry.isFile()) {
+      files.push(join(dir, entry.name));
+    }
+  }
+  return files;
+}
+
+// src/migrate.ts
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".mts", ".cts", ".jsx", ".tsx", ".vue", ".astro", ".mdx"]);
+var AUDIT_EXTRA_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less", ".styl", ".html", ".json", ".yaml", ".yml"]);
+var CONFIG_FILE = /(^|\.)config\.[cm]?[jt]s$/i;
+var RESIDUAL_REFERENCE = /['"`]primevue(?=[/'"`])|@primevue\/|\/primevue@/;
+function readText(file) {
+  const text = readFileSync2(file, "utf8");
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function hasOpenVue(dir) {
+  if (existsSync(join2(dir, "node_modules", "openvue"))) return true;
+  const packageJson = join2(dir, "package.json");
+  if (!existsSync(packageJson)) return false;
+  try {
+    const pkg = JSON.parse(readText(packageJson));
+    for (const section of ["dependencies", "devDependencies"]) {
+      const deps = pkg[section];
+      if (deps && typeof deps === "object" && Object.keys(deps).some((key) => key === "openvue" || key.startsWith("@openvue/"))) return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function detectPackageManager(dir) {
+  let current = dir;
+  for (; ; ) {
+    if (existsSync(join2(current, "pnpm-lock.yaml")) || existsSync(join2(current, "pnpm-workspace.yaml"))) return "pnpm";
+    if (existsSync(join2(current, "yarn.lock"))) return "yarn";
+    if (existsSync(join2(current, "bun.lock")) || existsSync(join2(current, "bun.lockb"))) return "bun";
+    if (existsSync(join2(current, "package-lock.json"))) return "npm";
+    const packageJson = join2(current, "package.json");
+    if (existsSync(packageJson)) {
+      try {
+        const field = JSON.parse(readText(packageJson)).packageManager;
+        const name = typeof field === "string" ? field.split("@")[0] : "";
+        if (name === "pnpm" || name === "yarn" || name === "bun" || name === "npm") return name;
+      } catch {
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) return "npm";
+    current = parent;
+  }
+}
+var INSTALL_COMMANDS = {
+  npm: "npm install",
+  pnpm: "pnpm install",
+  yarn: "yarn install",
+  bun: "bun install"
+};
+var LOCKFILES = /* @__PURE__ */ new Set(["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock"]);
+function isAuditFile(file) {
+  const name = basename(file);
+  if (LOCKFILES.has(name)) return false;
+  return SOURCE_EXTENSIONS.has(extname(file)) || AUDIT_EXTRA_EXTENSIONS.has(extname(file)) || name === "package.json" || /^(tsconfig|jsconfig)[^/\\]*\.json$/.test(name);
+}
+function auditResiduals(dir, files) {
+  const residuals = [];
+  for (const file of files) {
+    if (!isAuditFile(file)) continue;
+    const lines = readText(file).split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (RESIDUAL_REFERENCE.test(lines[i]) && !lines[i].includes("npm:openvue")) {
+        residuals.push({ file: relative(dir, file).replace(/\\/g, "/"), line: i + 1, text: lines[i].trim() });
+      }
+    }
+  }
+  return residuals;
+}
+function migrate(options) {
+  const { dir, dry = false, alias = true } = options;
+  const mode = hasOpenVue(dir) ? "sources-only" : "full";
+  const changedFiles = [];
+  const warnings = [];
+  const notes = [];
+  const skippedKeyFiles = /* @__PURE__ */ new Set();
+  const unknownScoped = /* @__PURE__ */ new Set();
+  const files = walk(dir);
+  let oldPrimevueRange = null;
+  let rootPackageJsonFailed = false;
+  for (const file of files) {
+    const name = basename(file);
+    const displayPath = relative(dir, file).replace(/\\/g, "/");
+    if (mode === "sources-only" && (name === "package.json" || name === "pnpm-workspace.yaml")) continue;
+    if (name === "package.json") {
+      const text = readText(file);
+      let result;
+      try {
+        result = rewritePackageJson(text);
+      } catch {
+        warnings.push(`${displayPath}: could not be parsed as JSON, skipped.`);
+        if (displayPath === "package.json") rootPackageJsonFailed = true;
+        continue;
+      }
+      if (result.oldPrimevueRange !== null && oldPrimevueRange === null) oldPrimevueRange = result.oldPrimevueRange;
+      result.unknownScoped.forEach((pkg) => unknownScoped.add(pkg));
+      result.notes.forEach((note) => notes.push(`${displayPath}: ${note}`));
+      if (result.changed) {
+        if (!dry) writeFileSync(file, result.text);
+        changedFiles.push({ file: displayPath, changes: result.renamed.length + result.notes.length, renamed: result.renamed });
+      }
+    } else if (name === "pnpm-workspace.yaml") {
+      const text = readFileSync2(file, "utf8");
+      const result = rewriteWorkspaceYaml(text);
+      if (result.count > 0) {
+        if (!dry) writeFileSync(file, result.text);
+        changedFiles.push({ file: displayPath, changes: result.count });
+      }
+    } else if (SOURCE_EXTENSIONS.has(extname(file))) {
+      const text = readFileSync2(file, "utf8");
+      const result = rewriteSource(text, { configFile: CONFIG_FILE.test(name) });
+      if (result.skippedKeys.length > 0) skippedKeyFiles.add(displayPath);
+      result.unknownScoped.forEach((pkg) => unknownScoped.add(pkg));
+      if (result.count > 0) {
+        if (!dry) writeFileSync(file, result.code);
+        changedFiles.push({ file: displayPath, changes: result.count });
+      }
+    }
+  }
+  const packageManager = detectPackageManager(dir);
+  const rootPackageJson = join2(dir, "package.json");
+  if (mode === "full" && alias && changedFiles.length > 0 && !rootPackageJsonFailed && existsSync(rootPackageJson)) {
+    try {
+      const result = addCompatAlias(readText(rootPackageJson), packageManager);
+      if (result.added) {
+        if (!dry) writeFileSync(rootPackageJson, result.text);
+        notes.push(`package.json: ${dry ? "would add" : "added"} override "primevue" -> "npm:openvue" so third-party libraries that (peer-)depend on primevue resolve to OpenVue. Remove it once your dependencies are OpenVue-native.`);
+      }
+    } catch {
+      warnings.push("package.json: could not add the primevue -> openvue compatibility override; add it manually if any of your dependencies require primevue.");
+    }
+  }
+  if (oldPrimevueRange !== null) {
+    const majorMatch = /\d+/.exec(oldPrimevueRange);
+    const major = majorMatch ? parseInt(majorMatch[0], 10) : null;
+    if (major !== null && major < 4) {
+      warnings.push(
+        `Your project used primevue@${oldPrimevueRange}, which predates the OpenVue fork point (PrimeVue 4.x). Apply the PrimeVue v${major} -> v4 migration guide before or after this codemod \u2014 renaming packages alone will not be enough.`
+      );
+    }
+  }
+  for (const file of skippedKeyFiles) {
+    warnings.push(`${file}: found a quoted 'primevue' object key and left it unchanged \u2014 the Nuxt module config key is still 'primevue' in OpenVue. Review it if it was meant as something else (e.g. a bundler alias).`);
+  }
+  for (const pkg of unknownScoped) {
+    warnings.push(`${pkg} is not a package OpenVue publishes; it was left unchanged. Review it manually.`);
+  }
+  const residuals = dry ? [] : auditResiduals(dir, files);
+  return { mode, changedFiles, warnings, notes, residuals, failed: rootPackageJsonFailed, oldPrimevueRange, packageManager, installCommand: INSTALL_COMMANDS[packageManager] };
+}
+
+// src/index.ts
+var HELP = `openvue-migrate ${OPENVUE_VERSION}
+
+Migrates a PrimeVue project to OpenVue in one run: rewrites package names in
+package.json / pnpm-workspace.yaml and module specifiers in source files, adds
+a package-manager override so third-party libraries that depend on primevue
+resolve to OpenVue, and installs the migrated dependencies.
+
+If OpenVue is already installed (found in package.json or node_modules), only
+source files are rewritten \u2014 dependencies and node_modules are left untouched
+and no install runs.
+
+Usage:
+  npx @openvue/migrate [dir] [options]
+
+Options:
+  --dry         Report what would change without writing any files
+  --no-install  Skip the package manager install after rewriting
+  --no-alias    Do not add the primevue -> openvue override to package.json
+  --force       Run even if the git working tree has uncommitted changes
+  --help        Show this help
+  --version     Print the version
+`;
+var KNOWN_FLAGS = ["--dry", "--force", "--no-install", "--no-alias"];
+var useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+var bold = (text) => useColor ? `\x1B[1m${text}\x1B[0m` : text;
+var green = (text) => useColor ? `\x1B[32m${text}\x1B[0m` : text;
+var yellow = (text) => useColor ? `\x1B[33m${text}\x1B[0m` : text;
+function isGitTreeDirty(dir) {
+  const inRepo = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: dir, encoding: "utf8", shell: process.platform === "win32" });
+  if (inRepo.status !== 0 || inRepo.stdout.trim() !== "true") return false;
+  const status = spawnSync("git", ["status", "--porcelain"], { cwd: dir, encoding: "utf8", shell: process.platform === "win32" });
+  return status.status === 0 && status.stdout.trim().length > 0;
+}
+function run() {
+  const args = process.argv.slice(2);
+  if (args.includes("--help") || args.includes("-h")) {
+    console.log(HELP);
+    return 0;
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(OPENVUE_VERSION);
+    return 0;
+  }
+  const dry = args.includes("--dry");
+  const force = args.includes("--force");
+  const install = !args.includes("--no-install");
+  const alias = !args.includes("--no-alias");
+  const unknownFlags = args.filter((arg) => arg.startsWith("-") && !KNOWN_FLAGS.includes(arg));
+  if (unknownFlags.length > 0) {
+    console.error(`Unknown option: ${unknownFlags[0]}
+
+${HELP}`);
+    return 1;
+  }
+  const positional = args.filter((arg) => !arg.startsWith("-"));
+  const dir = resolve(positional[0] ?? ".");
+  if (!existsSync2(dir) || !statSync(dir).isDirectory()) {
+    console.error(`Not a directory: ${dir}`);
+    return 1;
+  }
+  if (!dry && !force && isGitTreeDirty(dir)) {
+    console.error(yellow("Your git working tree has uncommitted changes. Commit or stash them first so the migration is easy to review and revert, or re-run with --force."));
+    return 1;
+  }
+  console.log(bold(`openvue-migrate ${OPENVUE_VERSION}`) + (dry ? yellow(" (dry run \u2014 no files will be written)") : ""));
+  console.log(`Migrating ${dir}
+`);
+  const result = migrate({ dir, dry, alias });
+  if (result.changedFiles.length === 0) {
+    console.log("No PrimeVue references found \u2014 nothing to do.");
+  } else {
+    const total = result.changedFiles.reduce((sum, file) => sum + file.changes, 0);
+    console.log(bold(`${dry ? "Would rewrite" : "Rewrote"} ${total} reference${total === 1 ? "" : "s"} in ${result.changedFiles.length} file${result.changedFiles.length === 1 ? "" : "s"}:`));
+    for (const file of result.changedFiles) {
+      console.log(green(`  ${file.file}`) + ` (${file.changes})`);
+      for (const rename of file.renamed ?? []) {
+        console.log(`      ${rename}`);
+      }
+    }
+  }
+  for (const note of result.notes) {
+    console.log(`
+Note: ${note}`);
+  }
+  for (const warning of result.warnings) {
+    console.log("\n" + yellow(`Warning: ${warning}`));
+  }
+  if (result.residuals.length > 0) {
+    console.log("\n" + yellow(bold(`${result.residuals.length} PrimeVue reference${result.residuals.length === 1 ? "" : "s"} could not be rewritten automatically \u2014 review them:`)));
+    for (const residual of result.residuals.slice(0, 25)) {
+      console.log(yellow(`  ${residual.file}:${residual.line}`) + `  ${residual.text.slice(0, 120)}`);
+    }
+    if (result.residuals.length > 25) console.log(yellow(`  ...and ${result.residuals.length - 25} more.`));
+    console.log("Some of these may be intentional (the Nuxt 'primevue' config key, docs, comments); anything that is an import or dependency needs a manual fix.");
+  }
+  if (result.failed) {
+    console.error(yellow(bold("\nThe root package.json could not be rewritten \u2014 fix it (see warnings above) and re-run. Skipping the install so a broken migration is not masked.")));
+    return 1;
+  }
+  if (result.changedFiles.length > 0 && !dry) {
+    if (result.mode === "sources-only") {
+      console.log(bold("\nOpenVue is already installed \u2014 dependencies and node_modules were left untouched; only source files were rewritten."));
+    } else if (install) {
+      console.log(bold(`
+Running ${result.installCommand}...
+`));
+      const installRun = spawnSync(result.installCommand, { cwd: dir, stdio: "inherit", shell: true });
+      if (installRun.status !== 0) {
+        console.error(yellow(`
+${result.installCommand} failed \u2014 fix the install errors above and re-run it. The source migration itself is complete.`));
+        return typeof installRun.status === "number" ? installRun.status : 1;
+      }
+      console.log(bold("\nDone. Review the diff and run your build."));
+    } else {
+      console.log(bold("\nNext step:"));
+      console.log(`  Run: ${result.installCommand}`);
+    }
+  }
+  return 0;
+}
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(resolve(process.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) process.exit(run());
+export {
+  OPENVUE_VERSION,
+  addCompatAlias,
+  auditResiduals,
+  detectPackageManager,
+  hasOpenVue,
+  migrate,
+  renameSpecifier,
+  rewritePackageJson,
+  rewriteSource,
+  rewriteWorkspaceYaml
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@openvue/migrate",
+  "version": "0.0.1-alpha.2",
+  "author": "OpenVue Contributors",
+  "description": "Codemod that migrates a PrimeVue project to OpenVue by rewriting package names and import specifiers",
+  "homepage": "https://github.com/openvi-foundation/openvue",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openvi-foundation/openvue.git",
+    "directory": "packages/migrate"
+  },
+  "bugs": {
+    "url": "https://github.com/openvi-foundation/openvue/issues"
+  },
+  "keywords": [
+    "primevue",
+    "openvue",
+    "migration",
+    "codemod",
+    "vue"
+  ],
+  "bin": {
+    "openvue-migrate": "./dist/index.js"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "devDependencies": {
+    "@types/node": "^22.12.0",
+    "tsup": "^8.1.0",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "NODE_ENV=production INPUT_DIR=src/ OUTPUT_DIR=dist/ pnpm run build:package",
+    "build:package": "pnpm run build:prebuild && tsup",
+    "build:prebuild": "node ./scripts/prebuild.mjs",
+    "test:unit": "tsc --noEmit && vitest run",
+    "test:unit:watch": "vitest watch",
+    "typecheck": "tsc --noEmit",
+    "dev:link": "pnpm link --global && npm link"
+  }
+}