@olegkuibar/plunk 0.2.0-canary.04ff96f

package/dist/tailwind-source-JBBEIXIJ.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import "./chunk-KYDBD2KQ.mjs";
+
+// src/utils/tailwind-source.ts
+import { readFile, readdir, writeFile } from "fs/promises";
+import { join, dirname, relative } from "path";
+var IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".plunk", "dist", ".git"]);
+async function findTailwindCss(projectRoot) {
+  let entries;
+  try {
+    entries = await readdir(projectRoot, { recursive: true, encoding: "utf-8" });
+  } catch {
+    return null;
+  }
+  const cssFiles = entries.filter((entry) => {
+    if (!entry.endsWith(".css")) return false;
+    const parts = entry.replace(/\\/g, "/").split("/");
+    return !parts.some((p) => IGNORED_DIRS.has(p));
+  }).map((entry) => join(projectRoot, entry));
+  for (const file of cssFiles) {
+    let content;
+    try {
+      content = await readFile(file, "utf-8");
+    } catch {
+      continue;
+    }
+    if (content.includes('@import "tailwindcss"') || content.includes("@import 'tailwindcss'")) {
+      return file;
+    }
+  }
+  return null;
+}
+async function addTailwindSource(cssPath, packageName, projectRoot) {
+  let content;
+  try {
+    content = await readFile(cssPath, "utf-8");
+  } catch {
+    return { modified: false, error: "could not read CSS file" };
+  }
+  if (content.includes(`node_modules/${packageName}`)) {
+    return { modified: false };
+  }
+  const sourcePath = computeSourcePath(cssPath, packageName, projectRoot);
+  const directiveRegex = /^@(import|source|plugin|theme)\s.+$/gm;
+  let lastMatch = null;
+  let match;
+  while ((match = directiveRegex.exec(content)) !== null) {
+    lastMatch = match;
+  }
+  const sourceLine = `@source "${sourcePath}";`;
+  if (lastMatch) {
+    const insertPos = lastMatch.index + lastMatch[0].length;
+    content = content.slice(0, insertPos) + "\n" + sourceLine + content.slice(insertPos);
+  } else {
+    content = sourceLine + "\n" + content;
+  }
+  await writeFile(cssPath, content);
+  return { modified: true };
+}
+async function removeTailwindSource(cssPath, packageName) {
+  let content;
+  try {
+    content = await readFile(cssPath, "utf-8");
+  } catch {
+    return { modified: false };
+  }
+  const escaped = packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const sourceRegex = new RegExp(
+    `^@source\\s+["'][^"']*node_modules/${escaped}["'];?\\s*\\n?`,
+    "m"
+  );
+  if (!sourceRegex.test(content)) {
+    return { modified: false };
+  }
+  content = content.replace(sourceRegex, "");
+  await writeFile(cssPath, content);
+  return { modified: true };
+}
+function computeSourcePath(cssPath, packageName, projectRoot) {
+  const cssDir = dirname(cssPath);
+  const targetPath = join(projectRoot, "node_modules", packageName);
+  return relative(cssDir, targetPath).replace(/\\/g, "/");
+}
+export {
+  addTailwindSource,
+  findTailwindCss,
+  removeTailwindSource
+};

package/dist/update-SKDSA673.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  inject
+} from "./chunk-CZM4TNAI.mjs";
+import "./chunk-34UXZ622.mjs";
+import {
+  addLink,
+  readConsumerState
+} from "./chunk-GAAB2TLH.mjs";
+import {
+  errorWithSuggestion
+} from "./chunk-S4HJSJ32.mjs";
+import {
+  findStoreEntry
+} from "./chunk-W3C72UKC.mjs";
+import {
+  Timer
+} from "./chunk-XZK5T4GK.mjs";
+import "./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,
+  verbose
+} from "./chunk-I6SN7BBN.mjs";
+import "./chunk-KYDBD2KQ.mjs";
+
+// src/commands/update.ts
+import { resolve } from "path";
+var update_default = defineCommand({
+  meta: {
+    name: "update",
+    description: "Pull latest versions from the store for linked packages"
+  },
+  args: {
+    package: {
+      type: "positional",
+      description: "Package name to update (default: all linked)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    suppressHumanOutput();
+    const timer = new Timer();
+    const consumerPath = resolve(".");
+    const state = await readConsumerState(consumerPath);
+    const links = Object.entries(state.links);
+    if (links.length === 0) {
+      consola.info("No linked packages in this project");
+      output({ updated: 0, skipped: 0 });
+      return;
+    }
+    const toUpdate = args.package ? links.filter(([name]) => name === args.package) : links;
+    if (args.package && toUpdate.length === 0) {
+      errorWithSuggestion(`Package "${args.package}" is not linked in this project`);
+      process.exit(1);
+    }
+    let updated = 0;
+    let skipped = 0;
+    for (const [packageName, link] of toUpdate) {
+      const entry = await findStoreEntry(packageName);
+      if (!entry) {
+        consola.warn(`Store entry missing for ${packageName}. Re-publish it.`);
+        continue;
+      }
+      if (entry.meta.contentHash === link.contentHash) {
+        verbose(`[update] ${packageName}@${entry.version} already up to date`);
+        skipped++;
+        continue;
+      }
+      const result = await inject(entry, consumerPath, link.packageManager);
+      const updatedLink = {
+        ...link,
+        version: entry.version,
+        contentHash: entry.meta.contentHash,
+        linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await addLink(consumerPath, packageName, updatedLink);
+      consola.success(
+        `Updated ${packageName}@${entry.version} (${result.copied} files changed)`
+      );
+      updated++;
+    }
+    consola.info(
+      `Update complete: ${updated} updated, ${skipped} unchanged in ${timer.elapsed()}`
+    );
+    output({ updated, skipped, elapsed: timer.elapsedMs() });
+  }
+});
+export {
+  update_default as default
+};

package/dist/vite-config-BAK67JHB.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import "./chunk-KYDBD2KQ.mjs";
+
+// src/utils/vite-config.ts
+import { readFile, writeFile } from "fs/promises";
+function detectIndent(content) {
+  const match = content.match(/^(\s+)\S/m);
+  return match?.[1] || "  ";
+}
+function hasPlunkPlugin(content) {
+  return content.includes("@olegkuibar/plunk/vite") || content.includes("vite-plugin-plunk");
+}
+function parsePluginItems(str) {
+  const items = [];
+  let current = "";
+  let depth = 0;
+  for (const ch of str) {
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      const trimmed2 = current.trim();
+      if (trimmed2) items.push(trimmed2);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  const trimmed = current.trim();
+  if (trimmed) items.push(trimmed);
+  return items;
+}
+function formatPlugins(items, indent) {
+  if (items.length === 0) return "[]";
+  if (items.length === 1) return `[${items[0]}]`;
+  const inner = items.map((i) => `${indent}${indent}${i},`).join("\n");
+  return `[
+${inner}
+${indent}]`;
+}
+async function addPlunkVitePlugin(configPath) {
+  let content;
+  try {
+    content = await readFile(configPath, "utf-8");
+  } catch {
+    return { modified: false, error: "could not read config file" };
+  }
+  if (hasPlunkPlugin(content)) {
+    return { modified: false };
+  }
+  const indent = detectIndent(content);
+  const pluginsRegex = /plugins\s*:\s*\[([\s\S]*?)\]/;
+  const pluginsMatch = pluginsRegex.exec(content);
+  if (pluginsMatch) {
+    const items = parsePluginItems(pluginsMatch[1]);
+    items.push("plunk()");
+    const newPlugins = formatPlugins(items, indent);
+    content = content.replace(pluginsRegex, `plugins: ${newPlugins}`);
+  } else {
+    const configObjRegex = /(?:defineConfig\s*\(\s*\{|export\s+default\s+\{)/;
+    const configObjMatch = configObjRegex.exec(content);
+    if (configObjMatch) {
+      const insertPos = configObjMatch.index + configObjMatch[0].length;
+      const newSection = `
+${indent}plugins: [plunk()],`;
+      content = content.slice(0, insertPos) + newSection + content.slice(insertPos);
+    } else {
+      return {
+        modified: false,
+        error: "unrecognized Vite config pattern"
+      };
+    }
+  }
+  const importLine = `import plunk from "@olegkuibar/plunk/vite";
+`;
+  const lastImportRegex = /^import\s.+$/gm;
+  let lastImportEnd = 0;
+  let match;
+  while ((match = lastImportRegex.exec(content)) !== null) {
+    lastImportEnd = match.index + match[0].length;
+  }
+  if (lastImportEnd > 0) {
+    content = content.slice(0, lastImportEnd) + "\n" + importLine + content.slice(lastImportEnd + 1);
+  } else {
+    content = importLine + "\n" + content;
+  }
+  await writeFile(configPath, content);
+  return { modified: true };
+}
+async function removeFromViteConfig(configPath) {
+  let content;
+  try {
+    content = await readFile(configPath, "utf-8");
+  } catch {
+    return { modified: false };
+  }
+  if (!hasPlunkPlugin(content)) {
+    return { modified: false };
+  }
+  let modified = false;
+  const importRegex = /^import\s+\w+\s+from\s+["']@olegkuibar\/plunk\/vite["'];?\s*\n?/m;
+  if (importRegex.test(content)) {
+    content = content.replace(importRegex, "");
+    modified = true;
+  }
+  const pluginsRegex = /plugins\s*:\s*\[([\s\S]*?)\]/;
+  const pluginsMatch = pluginsRegex.exec(content);
+  if (pluginsMatch) {
+    const items = parsePluginItems(pluginsMatch[1]);
+    const filtered = items.filter(
+      (item) => !item.startsWith("plunk(")
+    );
+    if (filtered.length !== items.length) {
+      const indent = detectIndent(content);
+      const newPlugins = formatPlugins(filtered, indent);
+      content = content.replace(pluginsRegex, `plugins: ${newPlugins}`);
+      modified = true;
+    }
+  }
+  if (modified) {
+    await writeFile(configPath, content);
+  }
+  return { modified };
+}
+export {
+  addPlunkVitePlugin,
+  removeFromViteConfig
+};

package/dist/vite-plugin.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from 'vite';
+
+declare function plunkPlugin(): Plugin;
+
+export { plunkPlugin as default };

package/dist/vite-plugin.mjs

@@ -0,0 +1,42 @@
+// src/vite-plugin.ts
+import { join, normalize } from "path";
+import { rm } from "fs/promises";
+function plunkPlugin() {
+  let plunkStateFile;
+  let cacheDir;
+  return {
+    name: "vite-plugin-plunk",
+    apply: "serve",
+    configResolved(config) {
+      plunkStateFile = normalize(join(config.root, ".plunk", "state.json"));
+      cacheDir = config.cacheDir;
+    },
+    configureServer(server) {
+      server.watcher.add(plunkStateFile);
+      server.watcher.on("change", async (changedPath) => {
+        if (normalize(changedPath) !== plunkStateFile) return;
+        server.config.logger.info("[plunk] Detected injection, reloading...", {
+          timestamp: true
+        });
+        try {
+          await rm(cacheDir, { recursive: true, force: true });
+        } catch {
+          server.config.logger.warn(
+            "[plunk] Could not clear Vite cache (locked?). Browser may load stale deps.",
+            { timestamp: true }
+          );
+        }
+        const seen = /* @__PURE__ */ new Set();
+        for (const mod of server.moduleGraph.idToModuleMap.values()) {
+          if (mod.id?.endsWith(".css") || mod.id?.includes("lang.css")) {
+            server.moduleGraph.invalidateModule(mod, seen);
+          }
+        }
+        server.ws.send({ type: "full-reload", path: "*" });
+      });
+    }
+  };
+}
+export {
+  plunkPlugin as default
+};

package/dist/workspace-76HJPAK2.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"node:module";globalThis.require=__cr(import.meta.url);
+import {
+  exists
+} from "./chunk-HKNM3UWU.mjs";
+import "./chunk-I6SN7BBN.mjs";
+import "./chunk-KYDBD2KQ.mjs";
+
+// src/utils/workspace.ts
+import { readFile } from "fs/promises";
+import { join, dirname } from "path";
+async function findWorkspaceRoot(startDir) {
+  let dir = startDir;
+  for (; ; ) {
+    if (await exists(join(dir, "pnpm-workspace.yaml"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function parseCatalogs(workspaceRoot) {
+  const result = { default: {}, named: {} };
+  const filePath = join(workspaceRoot, "pnpm-workspace.yaml");
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch {
+    return result;
+  }
+  const lines = content.split(/\r?\n/);
+  let state = "top";
+  let currentNamedCatalog = "";
+  for (const line of lines) {
+    if (line.trim() === "" || line.trim().startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    if (indent === 0) {
+      if (line.startsWith("catalog:")) {
+        state = "default-catalog";
+        continue;
+      }
+      if (line.startsWith("catalogs:")) {
+        state = "named-catalogs";
+        continue;
+      }
+      state = "top";
+      continue;
+    }
+    if (state === "default-catalog" && indent >= 2) {
+      const kv = parseKeyValue(line);
+      if (kv) result.default[kv[0]] = kv[1];
+      continue;
+    }
+    if (state === "named-catalogs" && indent >= 2 && indent < 4) {
+      const trimmed = line.trim();
+      if (trimmed.endsWith(":")) {
+        currentNamedCatalog = trimmed.slice(0, -1);
+        result.named[currentNamedCatalog] = {};
+        state = "named-catalog-entries";
+      }
+      continue;
+    }
+    if (state === "named-catalog-entries" && indent >= 4) {
+      const kv = parseKeyValue(line);
+      if (kv && currentNamedCatalog) {
+        result.named[currentNamedCatalog][kv[0]] = kv[1];
+      }
+      continue;
+    }
+    if (state === "named-catalog-entries" && indent >= 2 && indent < 4) {
+      const trimmed = line.trim();
+      if (trimmed.endsWith(":")) {
+        currentNamedCatalog = trimmed.slice(0, -1);
+        result.named[currentNamedCatalog] = {};
+      } else {
+        state = "named-catalogs";
+      }
+      continue;
+    }
+  }
+  return result;
+}
+function parseKeyValue(line) {
+  const trimmed = line.trim();
+  const colonIdx = trimmed.indexOf(":");
+  if (colonIdx <= 0) return null;
+  const key = trimmed.slice(0, colonIdx).trim();
+  const value = trimmed.slice(colonIdx + 1).trim();
+  if (!key || !value) return null;
+  const unquoted = value.replace(/^["']|["']$/g, "");
+  return [key, unquoted];
+}
+export {
+  findWorkspaceRoot,
+  parseCatalogs
+};

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@olegkuibar/plunk",
+  "version": "0.2.0-canary.04ff96f",
+  "description": "Modern local package development tool. Smart file copying into node_modules — no symlinks, no git contamination.",
+  "type": "module",
+  "bin": {
+    "plunk": "./dist/cli.mjs"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./vite": {
+      "types": "./dist/vite-plugin.d.ts",
+      "import": "./dist/vite-plugin.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "vite": [
+        "./dist/vite-plugin.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "npm",
+    "link",
+    "local",
+    "development",
+    "yalc",
+    "package",
+    "monorepo",
+    "pnpm",
+    "yarn",
+    "bun",
+    "symlink",
+    "copy",
+    "hmr"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oleg-kuibar/plunk.git"
+  },
+  "homepage": "https://github.com/oleg-kuibar/plunk#readme",
+  "bugs": {
+    "url": "https://github.com/oleg-kuibar/plunk/issues"
+  },
+  "author": "Oleg Kuibar (https://github.com/oleg-kuibar)",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "@types/picomatch": "^4.0.2",
+    "@types/proper-lockfile": "^4.1.4",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "vite": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0",
+    "citty": "^0.2.1",
+    "consola": "^3.4.2",
+    "p-limit": "^7.3.0",
+    "picocolors": "^1.1.1",
+    "picomatch": "^4.0.3",
+    "proper-lockfile": "^4.1.2",
+    "tinypool": "^2.1.0",
+    "xxhash-wasm": "^1.1.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  }
+}