@olegkuibar/plunk 0.2.0-canary.04ff96f

package/dist/init-SWCNRISY.mjs

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  addPostinstall,
+  ensureGitignore
+} from "./chunk-ZQCGJUBJ.mjs";
+import {
+  detectBuildCommand
+} from "./chunk-XMIZ7OUZ.mjs";
+import {
+  detectBundler,
+  detectPackageManager
+} from "./chunk-34UXZ622.mjs";
+import {
+  readConsumerState,
+  writeConsumerState
+} from "./chunk-GAAB2TLH.mjs";
+import {
+  Timer
+} from "./chunk-XZK5T4GK.mjs";
+import {
+  require_picocolors
+} from "./chunk-PUSXMPOF.mjs";
+import "./chunk-EDUXIQ5W.mjs";
+import {
+  output,
+  suppressHumanOutput
+} from "./chunk-ZOYNYK5Y.mjs";
+import {
+  defineCommand
+} from "./chunk-CSMZ6DZA.mjs";
+import {
+  ensureDir,
+  exists
+} from "./chunk-HKNM3UWU.mjs";
+import {
+  consola
+} from "./chunk-I6SN7BBN.mjs";
+import {
+  __toESM
+} from "./chunk-KYDBD2KQ.mjs";
+
+// src/commands/init.ts
+import { resolve, join, basename } from "path";
+import { readFile, writeFile } from "fs/promises";
+var import_picocolors = __toESM(require_picocolors(), 1);
+var init_default = defineCommand({
+  meta: {
+    name: "init",
+    description: "Set up plunk in the current project"
+  },
+  args: {
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Skip confirmation prompts",
+      default: false
+    },
+    role: {
+      type: "string",
+      description: 'Project role: "consumer" or "library"'
+    }
+  },
+  async run({ args }) {
+    suppressHumanOutput();
+    const timer = new Timer();
+    const projectDir = resolve(".");
+    const skipPrompts = args.yes;
+    consola.info(`Initializing plunk in ${import_picocolors.default.cyan(projectDir)}
+`);
+    const detectedPm = await detectPackageManager(projectDir);
+    const lockfileNames = {
+      pnpm: "pnpm-lock.yaml",
+      bun: "bun.lockb",
+      yarn: "yarn.lock",
+      npm: "package-lock.json"
+    };
+    consola.success(
+      `Detected package manager: ${import_picocolors.default.cyan(detectedPm)}` + (lockfileNames[detectedPm] ? ` (from ${lockfileNames[detectedPm]})` : "")
+    );
+    let pm = detectedPm;
+    if (!skipPrompts) {
+      const confirm = await consola.prompt(`Use ${detectedPm}?`, {
+        type: "confirm",
+        initial: true
+      });
+      if (confirm === false) {
+        const choices = ["npm", "pnpm", "yarn", "bun"].filter(
+          (p) => p !== detectedPm
+        );
+        const selected = await consola.prompt("Select package manager:", {
+          type: "select",
+          options: choices.map((p) => ({ label: p, value: p }))
+        });
+        if (typeof selected === "string") {
+          pm = selected;
+        }
+      }
+    }
+    let role = "consumer";
+    if (args.role === "consumer" || args.role === "library") {
+      role = args.role;
+    } else if (!skipPrompts) {
+      const selected = await consola.prompt(
+        "How will you use plunk in this project?",
+        {
+          type: "select",
+          options: [
+            {
+              label: "Consumer (app) \u2014 I want to link packages INTO this project",
+              value: "consumer"
+            },
+            {
+              label: "Library (package) \u2014 I want to publish this package FOR other projects",
+              value: "library"
+            }
+          ]
+        }
+      );
+      if (selected === "library") {
+        role = "library";
+      }
+    }
+    consola.success(`Project role: ${import_picocolors.default.cyan(role)}`);
+    const gitignorePath = join(projectDir, ".gitignore");
+    const gitignoreUpdated = await ensureGitignore(gitignorePath);
+    if (gitignoreUpdated) {
+      consola.success("Added .plunk/ to .gitignore");
+    }
+    const pkgPath = join(projectDir, "package.json");
+    let libraryBuildCmd;
+    if (await exists(pkgPath)) {
+      if (role === "consumer") {
+        const postinstallAdded = await addPostinstall(pkgPath);
+        if (postinstallAdded) {
+          consola.success(
+            'Added "postinstall": "plunk restore" to package.json scripts'
+          );
+        }
+        let packageName = "{package-name}";
+        if (!skipPrompts) {
+          const input = await consola.prompt(
+            "Package name to link (leave blank to skip):",
+            { type: "text", default: "" }
+          );
+          if (typeof input === "string" && input.trim()) {
+            packageName = input.trim();
+          }
+        }
+        const addScriptAdded = await addScript(
+          pkgPath,
+          "plunk:add",
+          `plunk add ${packageName}`
+        );
+        if (addScriptAdded) {
+          consola.success(
+            `Added "plunk:add": "plunk add ${packageName}" to package.json scripts`
+          );
+        }
+      } else {
+        libraryBuildCmd = await detectBuildCommand2(pkgPath, pm, skipPrompts);
+        const added = await addLibraryScripts(pkgPath);
+        for (const name of added) {
+          consola.success(`Added "${name}" script to package.json`);
+        }
+      }
+    }
+    const plunkDir = join(projectDir, ".plunk");
+    if (!await exists(plunkDir)) {
+      await ensureDir(plunkDir);
+      await writeFile(
+        join(plunkDir, "state.json"),
+        JSON.stringify(
+          { version: "1", packageManager: pm, role, links: {} },
+          null,
+          2
+        )
+      );
+      consola.success("Created .plunk/ state directory");
+    } else {
+      const state = await readConsumerState(projectDir);
+      state.packageManager = pm;
+      state.role = role;
+      await writeConsumerState(projectDir, state);
+    }
+    if (role === "consumer") {
+      const bundler = await detectBundler(projectDir);
+      if (bundler.type === "vite" && bundler.configFile) {
+        consola.success(
+          `Detected bundler: ${import_picocolors.default.cyan("Vite")} (${basename(bundler.configFile)})`
+        );
+        const { addPlunkVitePlugin } = await import("./vite-config-BAK67JHB.mjs");
+        const viteResult = await addPlunkVitePlugin(bundler.configFile);
+        if (viteResult.modified) {
+          consola.success(`Added plunk plugin to ${basename(bundler.configFile)}`);
+        } else if (viteResult.error) {
+          consola.info(
+            `Add the Vite plugin for automatic dev server restarts:
+  ${import_picocolors.default.cyan('import plunk from "@olegkuibar/plunk/vite"')}
+  ${import_picocolors.default.cyan("plugins: [plunk()]")}`
+          );
+        }
+      } else if (bundler.type === "next" && bundler.configFile) {
+        consola.success(
+          `Detected bundler: ${import_picocolors.default.cyan("Next.js")} (${basename(bundler.configFile)})`
+        );
+        consola.info(
+          `Next.js transpilePackages will be auto-configured when you run ${import_picocolors.default.cyan("plunk add")}`
+        );
+      } else if (bundler.type) {
+        const names = {
+          webpack: "Webpack",
+          turbo: "Turbopack",
+          rollup: "Rollup"
+        };
+        consola.success(
+          `Detected bundler: ${import_picocolors.default.cyan(names[bundler.type] || bundler.type)} \u2014 no config needed, works out of the box`
+        );
+      }
+      console.log("");
+      consola.info(`${import_picocolors.default.bold("Next steps:")}`);
+      console.log(
+        `  1. ${import_picocolors.default.cyan("cd ../my-lib && plunk publish")}`
+      );
+      console.log(
+        `  2. ${import_picocolors.default.cyan("plunk add my-lib")}${bundler.type === "vite" ? "                     \u2190 auto-updates vite config" : bundler.type === "next" ? "                     \u2190 auto-updates next config" : ""}`
+      );
+      console.log(
+        `  3. ${import_picocolors.default.cyan("cd ../my-lib && plunk dev")}                  \u2190 watch + rebuild + auto-push`
+      );
+    } else {
+      console.log("");
+      consola.info(`${import_picocolors.default.bold("Next steps:")}`);
+      console.log(
+        `  1. ${import_picocolors.default.cyan("plunk publish")}                    \u2190 copy built files to plunk store`
+      );
+      console.log(
+        `  2. ${import_picocolors.default.cyan(`${pm} run plunk:dev`)}               \u2190 watch + rebuild + auto-push to consumers`
+      );
+      console.log(
+        `  3. In consumer project: ${import_picocolors.default.cyan("plunk add " + await readPkgName(pkgPath))}`
+      );
+    }
+    consola.info(`Done in ${timer.elapsed()}`);
+    output({
+      packageManager: pm,
+      role,
+      elapsed: timer.elapsedMs()
+    });
+  }
+});
+async function addScript(pkgPath, name, command) {
+  const content = await readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(content);
+  if (pkg.scripts?.[name]) return false;
+  if (!pkg.scripts) pkg.scripts = {};
+  pkg.scripts[name] = command;
+  const indent = content.match(/^(\s+)"/m)?.[1] || "  ";
+  await writeFile(pkgPath, JSON.stringify(pkg, null, indent) + "\n");
+  return true;
+}
+async function detectBuildCommand2(pkgPath, pm, skipPrompts) {
+  const packageDir = join(pkgPath, "..");
+  const detected = await detectBuildCommand(packageDir, pm);
+  if (detected) {
+    consola.success(`Detected build script: ${import_picocolors.default.cyan(detected)}`);
+    return detected;
+  }
+  const runPrefix = pm === "npm" ? "npm run " : `${pm} `;
+  if (!skipPrompts) {
+    consola.warn("No build script found in package.json");
+    const input = await consola.prompt(
+      "Build command (e.g. tsc, tsup, rollup -c):",
+      { type: "text", default: "" }
+    );
+    if (typeof input === "string" && input.trim()) {
+      return input.trim();
+    }
+  }
+  const fallback = `${runPrefix}build`;
+  consola.warn(
+    `Using ${import_picocolors.default.cyan(fallback)} as placeholder \u2014 add a "build" script to package.json`
+  );
+  return fallback;
+}
+async function addLibraryScripts(pkgPath) {
+  const added = [];
+  if (await addScript(pkgPath, "plunk:publish", "plunk publish")) {
+    added.push("plunk:publish");
+  }
+  if (await addScript(
+    pkgPath,
+    "plunk:dev",
+    "plunk dev"
+  )) {
+    added.push("plunk:dev");
+  }
+  return added;
+}
+async function readPkgName(pkgPath) {
+  try {
+    const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+    return pkg.name || "my-package";
+  } catch {
+    return "my-package";
+  }
+}
+export {
+  init_default as default
+};

package/dist/list-B77L2F34.mjs

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  readConsumerState
+} from "./chunk-GAAB2TLH.mjs";
+import {
+  getStoreEntry,
+  listStoreEntries
+} from "./chunk-W3C72UKC.mjs";
+import {
+  require_picocolors
+} from "./chunk-PUSXMPOF.mjs";
+import "./chunk-EDUXIQ5W.mjs";
+import {
+  output,
+  suppressHumanOutput
+} from "./chunk-ZOYNYK5Y.mjs";
+import {
+  defineCommand
+} from "./chunk-CSMZ6DZA.mjs";
+import "./chunk-HKNM3UWU.mjs";
+import {
+  consola
+} from "./chunk-I6SN7BBN.mjs";
+import {
+  __toESM
+} from "./chunk-KYDBD2KQ.mjs";
+
+// src/commands/list.ts
+import { resolve } from "path";
+var import_picocolors = __toESM(require_picocolors(), 1);
+var list_default = defineCommand({
+  meta: {
+    name: "list",
+    description: "List linked packages in current project or in the store"
+  },
+  args: {
+    store: {
+      type: "boolean",
+      description: "List all packages in the global plunk store",
+      default: false
+    }
+  },
+  async run({ args }) {
+    suppressHumanOutput();
+    if (args.store) {
+      await listStore();
+    } else {
+      await listProject();
+    }
+  }
+});
+async function listProject() {
+  const state = await readConsumerState(resolve("."));
+  const links = Object.entries(state.links);
+  if (links.length === 0) {
+    consola.info("No linked packages in this project");
+    output({ packages: [] });
+    return;
+  }
+  consola.info(`Linked packages (${links.length}):
+`);
+  const packages = [];
+  for (const [name, link] of links) {
+    const buildTag = link.buildId ? `[${link.buildId}]` : "[--------]";
+    let stale = false;
+    const storeEntry = await getStoreEntry(name, link.version);
+    if (storeEntry && storeEntry.meta.buildId && link.buildId && storeEntry.meta.buildId !== link.buildId) {
+      stale = true;
+    }
+    const staleTag = stale ? import_picocolors.default.yellow(" (stale)") : "";
+    console.log(
+      `  ${import_picocolors.default.cyan(name)} ${import_picocolors.default.dim("@" + link.version)} ${import_picocolors.default.dim(buildTag)}${staleTag}  \u2190 ${import_picocolors.default.dim(link.sourcePath)}`
+    );
+    packages.push({ name, version: link.version, buildId: link.buildId ?? null, stale, sourcePath: link.sourcePath });
+  }
+  output({ packages });
+}
+async function listStore() {
+  const entries = await listStoreEntries();
+  if (entries.length === 0) {
+    consola.info("Plunk store is empty");
+    output({ entries: [] });
+    return;
+  }
+  consola.info(`Store entries (${entries.length}):
+`);
+  const storeEntries = [];
+  for (const entry of entries) {
+    const age = getRelativeTime(new Date(entry.meta.publishedAt));
+    const buildTag = entry.meta.buildId ? `[${entry.meta.buildId}]` : "[--------]";
+    console.log(
+      `  ${import_picocolors.default.cyan(entry.name)} ${import_picocolors.default.dim("@" + entry.version)} ${import_picocolors.default.dim(buildTag)}  ${import_picocolors.default.dim(`published ${age}`)}`
+    );
+    console.log(`    ${import_picocolors.default.dim(`from: ${entry.meta.sourcePath}`)}`);
+    storeEntries.push({
+      name: entry.name,
+      version: entry.version,
+      buildId: entry.meta.buildId ?? null,
+      publishedAt: entry.meta.publishedAt,
+      sourcePath: entry.meta.sourcePath
+    });
+  }
+  output({ entries: storeEntries });
+}
+function getRelativeTime(date) {
+  const diff = Date.now() - date.getTime();
+  const seconds = Math.floor(diff / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+export {
+  list_default as default
+};

package/dist/migrate-X5TIC5SS.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  Timer
+} from "./chunk-XZK5T4GK.mjs";
+import {
+  require_picocolors
+} from "./chunk-PUSXMPOF.mjs";
+import {
+  output,
+  suppressHumanOutput
+} from "./chunk-ZOYNYK5Y.mjs";
+import {
+  defineCommand
+} from "./chunk-CSMZ6DZA.mjs";
+import {
+  exists
+} from "./chunk-HKNM3UWU.mjs";
+import {
+  consola
+} from "./chunk-I6SN7BBN.mjs";
+import {
+  __toESM
+} from "./chunk-KYDBD2KQ.mjs";
+
+// src/commands/migrate.ts
+import { resolve, join } from "path";
+import { readFile, writeFile, rm } from "fs/promises";
+var import_picocolors = __toESM(require_picocolors(), 1);
+var migrate_default = defineCommand({
+  meta: {
+    name: "migrate",
+    description: "Migrate from yalc to plunk"
+  },
+  async run() {
+    suppressHumanOutput();
+    const timer = new Timer();
+    const projectDir = resolve(".");
+    consola.info("Checking for yalc usage...\n");
+    const yalcDir = join(projectDir, ".yalc");
+    const yalcLockPath = join(projectDir, "yalc.lock");
+    const pkgPath = join(projectDir, "package.json");
+    const hasYalcDir = await exists(yalcDir);
+    const hasYalcLock = await exists(yalcLockPath);
+    if (!hasYalcDir && !hasYalcLock) {
+      consola.info("No yalc usage detected in this project.");
+      output({ migrated: false, packages: [] });
+      return;
+    }
+    const packages = [];
+    if (hasYalcLock) {
+      try {
+        const lockContent = await readFile(yalcLockPath, "utf-8");
+        const lock = JSON.parse(lockContent);
+        if (lock.packages) {
+          packages.push(...Object.keys(lock.packages));
+          consola.info(
+            `Found ${packages.length} yalc-linked package(s): ${packages.map((p) => import_picocolors.default.cyan(p)).join(", ")}`
+          );
+        }
+      } catch {
+        consola.warn("Could not parse yalc.lock");
+      }
+    }
+    if (await exists(pkgPath)) {
+      try {
+        const pkgContent = await readFile(pkgPath, "utf-8");
+        const pkg = JSON.parse(pkgContent);
+        let changed = false;
+        for (const depField of ["dependencies", "devDependencies", "peerDependencies"]) {
+          const deps = pkg[depField];
+          if (!deps) continue;
+          for (const [name, version] of Object.entries(deps)) {
+            if (typeof version === "string" && version.includes(".yalc/")) {
+              delete deps[name];
+              changed = true;
+              consola.info(`Removed file:.yalc/ reference for ${import_picocolors.default.cyan(name)}`);
+            }
+          }
+        }
+        if (changed) {
+          const indent = pkgContent.match(/^(\s+)"/m)?.[1] || "  ";
+          await writeFile(pkgPath, JSON.stringify(pkg, null, indent) + "\n");
+          consola.success("Cleaned up package.json");
+        }
+      } catch (err) {
+        consola.warn(`Could not clean package.json: ${err}`);
+      }
+    }
+    if (hasYalcDir) {
+      await rm(yalcDir, { recursive: true, force: true });
+      consola.success("Removed .yalc/ directory");
+    }
+    if (hasYalcLock) {
+      await rm(yalcLockPath, { force: true });
+      consola.success("Removed yalc.lock");
+    }
+    console.log("");
+    consola.info(`${import_picocolors.default.bold("Migration complete!")} Next steps:
+`);
+    console.log(`  1. ${import_picocolors.default.cyan("plunk init")}`);
+    if (packages.length > 0) {
+      for (const pkg of packages) {
+        console.log(
+          `  2. ${import_picocolors.default.cyan(`plunk add ${pkg} --from <path-to-${pkg}>`)}`
+        );
+      }
+    }
+    console.log(
+      `
+  Run ${import_picocolors.default.cyan("plunk doctor")} to verify your setup.
+`
+    );
+    consola.info(`Migrated in ${timer.elapsed()}`);
+    output({
+      migrated: true,
+      packages,
+      elapsed: timer.elapsedMs()
+    });
+  }
+});
+export {
+  migrate_default as default
+};