isotone 0.4.0 → 0.4.2

package/dist/cli.js

@@ -13,26 +13,26 @@ import {
   syncVariant,
   variantDir,
   writeActive
-} from "./chunk-7WGLOXRQ.js";
+} from "./chunk-DD6BKC3R.js";
 import {
   overlayGroups,
   variantAppliesTo
-} from "./chunk-SNGBNVH2.js";
+} from "./chunk-OSETWKGE.js";
 import {
-  checkUpdate,
-  version
-} from "./chunk-QT27DAPQ.js";
+  checkUpdate
+} from "./chunk-LHCQL5PA.js";
 import {
   readNotes,
   updateNotes
-} from "./chunk-DD767R7E.js";
+} from "./chunk-AP7O357L.js";
+import "./chunk-A4DX2V4C.js";
 
 // src/cli/index.ts
 import { realpathSync } from "fs";
 import { fileURLToPath } from "url";
 
 // src/cli/run.ts
-import { resolve as resolve3 } from "path";
+import { resolve as resolve2 } from "path";
 
 // src/cli/init.ts
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
@@ -124,7 +124,7 @@ function runInit(args, io) {
   }
   const { value: approachArg, rest: r1 } = extractFlag(args, "--approach");
   const { present: yes } = extractBoolFlag(r1, "--yes");
-  const json2 = args.includes("--json");
+  const json = args.includes("--json");
   if (help) {
     out(io, "Usage: isotone init                      look at this repo and recommend an approach");
     out(io, "       isotone init --approach <name>    print the setup for overlay, host or serve");
@@ -142,7 +142,7 @@ function runInit(args, io) {
     errOut(io, `Unknown approach "${approach}". Use host, overlay or serve.`);
     return 1;
   }
-  if (json2) {
+  if (json) {
     const instructions = [];
     printApproach({ ...io, stdout: { write: (line) => instructions.push(line) } }, approach, host);
     out(io, JSON.stringify({
@@ -757,308 +757,10 @@ async function runCheckUpdate(args, io) {
   return result.status === "unavailable" ? 1 : 0;
 }
 
-// src/cli/migrate.ts
-import { execFileSync } from "child_process";
-import { createHash, randomUUID } from "crypto";
-import { existsSync as existsSync3, lstatSync, readFileSync as readFileSync2, readdirSync as readdirSync2, renameSync, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { basename, dirname, extname, join as join3, relative as relative2, resolve as resolve2 } from "path";
-var OLD = "iso-iterate";
-var NEW = "isotone";
-var TEXT = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".json", ".jsonc", ".md", ".mdx", ".html", ".css", ".scss", ".sass", ".less", ".vue", ".svelte", ".yaml", ".yml", ".toml", ".sh"]);
-var SKIP = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", ".nuxt", ".output", "coverage", ".turbo"]);
-var LOCKS = /* @__PURE__ */ new Set(["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"]);
-function git(cwd, args, input) {
-  return execFileSync("git", args, { cwd, input, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], maxBuffer: 32 * 1024 * 1024 }).trimEnd();
-}
-function renamed(text) {
-  const keys = [];
-  const protect = (match, prefix, quote, value) => {
-    if (value === "iso-iterate-feedback" || value === "iso-iterate:knobs") return match;
-    const index = keys.push(value) - 1;
-    return `${prefix}${quote}\0KEY${index}\0${quote}`;
-  };
-  const protectedText = text.replace(/(\b(?:key|storageKey)\s*:\s*|["'](?:key|storageKey)["']\s*:\s*)(["'`])([\s\S]*?)\2/g, protect).replace(/(\b(?:localStorage|sessionStorage)\.(?:getItem|setItem|removeItem)\(\s*)(["'`])([\s\S]*?)\2/g, protect);
-  let result = protectedText.replace(/\biso-iterate@\d+\.\d+\.\d+(?:-[\da-zA-Z.-]+)?(?:\+[\da-zA-Z.-]+)?/g, `${NEW}@${version}`).replaceAll(OLD, NEW).replaceAll("iso-iter-", "isotone-").replaceAll("isoIterate", "isotone").replaceAll("IsoIterate", "Isotone").replaceAll("ISO_ITERATE", "ISOTONE").replaceAll("ISO_VARIANT", "ISOTONE_VARIANT");
-  keys.forEach((value, index) => {
-    result = result.replaceAll(`\0KEY${index}\0`, value);
-  });
-  return result;
-}
-function present(path) {
-  try {
-    lstatSync(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function textContents(buffer) {
-  if (buffer.includes(0)) return null;
-  const text = buffer.toString("utf8");
-  return Buffer.from(text).compare(buffer) === 0 && !feedback(text) ? text : null;
-}
-function safeFile(root, path) {
-  const parts = relative2(root, path).split(/[\\/]/);
-  if (parts.includes("..") || parts.some((part) => SKIP.has(part))) return false;
-  let current = root;
-  for (const part of parts) {
-    current = join3(current, part);
-    try {
-      if (lstatSync(current).isSymbolicLink()) return false;
-    } catch {
-      return false;
-    }
-  }
-  return lstatSync(path).isFile();
-}
-function walk(directory, visit, legacy, skipped) {
-  for (const entry of readdirSync2(directory, { withFileTypes: true })) {
-    const path = join3(directory, entry.name);
-    if (entry.isSymbolicLink()) {
-      if (entry.name === `.${OLD}`) legacy(path);
-      continue;
-    }
-    if (entry.isDirectory()) {
-      if (SKIP.has(entry.name)) continue;
-      if (present(join3(path, ".git"))) {
-        skipped?.(path);
-        continue;
-      }
-      if (entry.name === `.${OLD}`) legacy(path);
-      else if (entry.name !== ".isotone") walk(path, visit, legacy, skipped);
-    } else if (entry.isFile()) visit(path);
-  }
-}
-function json(text) {
-  try {
-    const data = JSON.parse(text);
-    return data && typeof data === "object" && !Array.isArray(data) ? data : null;
-  } catch {
-    return null;
-  }
-}
-function feedback(text) {
-  try {
-    const data = JSON.parse(text);
-    return Array.isArray(data) && data.some((note) => note && typeof note === "object" && typeof note.feedback === "string" && typeof note.id === "string");
-  } catch {
-    return false;
-  }
-}
-function packageText(text, path, conflicts) {
-  const pkg = json(text);
-  if (!pkg) {
-    conflicts.push(`Invalid package.json: ${path}`);
-    return text;
-  }
-  for (const key of ["overrides", "resolutions", "pnpm"]) {
-    if (JSON.stringify(pkg[key])?.includes(OLD)) conflicts.push(`Legacy package in ${path} (${key}). Review custom overrides/resolutions before migrating.`);
-  }
-  let changed = false;
-  const sections = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
-  if (sections.some((key) => Object.hasOwn(Object(pkg[key]), OLD)) && sections.some((key) => Object.hasOwn(Object(pkg[key]), NEW))) {
-    conflicts.push(`Both package names exist in ${path}. Resolve their dependency declarations before migrating.`);
-    return text;
-  }
-  for (const key of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
-    const deps = pkg[key];
-    if (!deps || typeof deps !== "object" || Array.isArray(deps) || !Object.hasOwn(deps, OLD)) continue;
-    const values = deps;
-    values[NEW] = version;
-    delete values[OLD];
-    changed = true;
-  }
-  if (!changed) return renamed(text);
-  const indent = /\n([\t ]+)"/.exec(text)?.[1] ?? "  ";
-  return renamed(JSON.stringify(pkg, null, indent)) + (text.endsWith("\n") ? "\n" : "");
-}
-function installStep(root, override) {
-  let directory = root;
-  let manager = override;
-  while (true) {
-    const pkg = existsSync3(join3(directory, "package.json")) ? json(readFileSync2(join3(directory, "package.json"), "utf8")) : null;
-    const declared = typeof pkg?.packageManager === "string" ? /^(npm|pnpm|yarn|bun)@/.exec(pkg.packageManager)?.[1] : void 0;
-    const found = /* @__PURE__ */ new Set();
-    if (existsSync3(join3(directory, "package-lock.json")) || existsSync3(join3(directory, "npm-shrinkwrap.json"))) found.add("npm");
-    if (existsSync3(join3(directory, "pnpm-lock.yaml"))) found.add("pnpm");
-    if (existsSync3(join3(directory, "yarn.lock"))) found.add("yarn");
-    if (existsSync3(join3(directory, "bun.lock")) || existsSync3(join3(directory, "bun.lockb"))) found.add("bun");
-    if (declared || found.size || dirname(directory) === directory || existsSync3(join3(directory, ".git"))) {
-      if (!manager && typeof pkg?.packageManager === "string" && !declared) return { install: null, warning: "Unsupported packageManager; run its install command to regenerate the lockfile." };
-      if (!manager && !declared && found.size > 1) return { install: null, warning: "Multiple lockfiles: pass --manager npm, pnpm, yarn or bun for an install command." };
-      manager ??= declared ?? [...found][0] ?? "npm";
-      const command = `${manager} install`;
-      return { install: { cwd: pkg || found.size ? directory : root, command } };
-    }
-    directory = dirname(directory);
-  }
-}
-function planMigration(cwd, manager) {
-  let root = resolve2(cwd);
-  let tracked = null;
-  try {
-    root = git(root, ["rev-parse", "--show-toplevel"]);
-    tracked = git(root, ["ls-files", "-z"]).split("\0").filter(Boolean);
-  } catch {
-  }
-  const plan = { root, edits: [], moves: [], blobs: /* @__PURE__ */ new Map(), conflicts: [], install: null, installs: [], warnings: [] };
-  const candidates = /* @__PURE__ */ new Set();
-  const legacyRoots = /* @__PURE__ */ new Set();
-  const addLegacy = (path) => {
-    if (legacyRoots.has(path)) return;
-    legacyRoots.add(path);
-    if (lstatSync(path).isSymbolicLink()) {
-      plan.conflicts.push(`Legacy directory is a symlink: ${relative2(root, path)}. Migrate its target separately.`);
-      return;
-    }
-    const destination = join3(dirname(path), ".isotone");
-    if (present(destination)) plan.conflicts.push(`Both ${relative2(root, path)} and ${relative2(root, destination)} exist; nothing will be overwritten.`);
-    plan.moves.push({ from: path, to: destination });
-    walk(path, (file) => candidates.add(file), (nested) => plan.conflicts.push(`Nested legacy directory: ${relative2(root, nested)}`));
-  };
-  if (tracked) for (const file of tracked) candidates.add(join3(root, file));
-  walk(root, (path) => {
-    const name = basename(path);
-    if (!tracked || dirname(path) === root && (["AGENTS.md", "package.json", ".gitignore", ".npmignore"].includes(name) || /^(?:vite|next|react-router|svelte|astro|nuxt)\.config\./.test(name))) candidates.add(path);
-  }, addLegacy, (path) => plan.warnings.push(`Separate Git checkout skipped: ${relative2(root, path)}. Migrate it separately.`));
-  if (tracked) {
-    const exclude = resolve2(root, git(root, ["rev-parse", "--git-path", "info/exclude"]));
-    if (existsSync3(exclude) && lstatSync(exclude).isFile() && !lstatSync(exclude).isSymbolicLink()) {
-      const before = readFileSync2(exclude, "utf8");
-      const after = renamed(before);
-      if (before !== after) plan.edits.push({ path: exclude, before, after, mode: lstatSync(exclude).mode, gitExclude: true });
-    }
-  }
-  for (const file of candidates) {
-    const name = basename(file);
-    if (LOCKS.has(name) || name === ".iteration-feedback.json" || !safeFile(root, file)) continue;
-    if (relative2(root, file).split(/[\\/]/).some((part) => part !== `.${OLD}` && renamed(part) !== part)) {
-      plan.conflicts.push(`Legacy name in a file path: ${relative2(root, file)}. Rename that file or directory and its local references before migrating.`);
-      continue;
-    }
-    if (!TEXT.has(extname(file)) && ![".gitignore", ".npmignore"].includes(name)) continue;
-    const before = textContents(readFileSync2(file));
-    if (before === null) continue;
-    for (const match of before.matchAll(/\biso-iterate@([^\s"'`;,)}\]]+)/g)) {
-      if (!/^(?:latest|\d+\.\d+\.\d+(?:-[\da-zA-Z.-]+)?(?:\+[\da-zA-Z.-]+)?)$/.test(match[1])) {
-        plan.conflicts.push(`Custom package version constraint in ${relative2(root, file)}. Replace it with the desired Isotone version before migrating.`);
-      }
-    }
-    const after = name === "package.json" ? packageText(before, relative2(root, file), plan.conflicts) : renamed(before);
-    if (after !== before) plan.edits.push({ path: file, before, after, mode: lstatSync(file).mode });
-  }
-  if (tracked) for (const file of candidates) {
-    if (basename(file) !== "variant.json" || !safeFile(root, file) || ![...legacyRoots].some((path) => file.startsWith(`${path}/`))) continue;
-    const before = readFileSync2(file, "utf8");
-    const existing = plan.edits.find((edit) => edit.path === file);
-    const data = json(existing?.after ?? before);
-    if (!data?.files || typeof data.files !== "object") continue;
-    let changed = false;
-    for (const [key, entry] of Object.entries(data.files)) {
-      if (!TEXT.has(extname(key)) && ![".gitignore", ".npmignore"].includes(basename(key))) continue;
-      if (!entry || typeof entry !== "object" || typeof entry.base !== "string" || !/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/.test(entry.base)) continue;
-      let base;
-      try {
-        base = textContents(execFileSync("git", ["cat-file", "blob", entry.base], { cwd: root, stdio: ["pipe", "pipe", "pipe"], maxBuffer: 32 * 1024 * 1024 }));
-      } catch {
-        continue;
-      }
-      if (base === null || basename(key) === ".iteration-feedback.json") continue;
-      const after = basename(key) === "package.json" ? packageText(base, key, []) : renamed(base);
-      if (after === base) continue;
-      const hash = createHash(entry.base.length === 64 ? "sha256" : "sha1").update(`blob ${Buffer.byteLength(after)}\0`).update(after).digest("hex");
-      entry.base = hash;
-      plan.blobs.set(hash, after);
-      changed = true;
-    }
-    if (changed) {
-      const after = `${JSON.stringify(data, null, 2)}
-`;
-      if (existing) existing.after = after;
-      else plan.edits.push({ path: file, before, after, mode: lstatSync(file).mode });
-    }
-  }
-  const packages = plan.edits.filter((edit) => basename(edit.path) === "package.json" && edit.before.includes(`"${OLD}"`));
-  for (const edit of packages) {
-    const step = installStep(dirname(edit.path), manager);
-    if (step.install && !plan.installs.some((existing) => existing.cwd === step.install?.cwd && existing.command === step.install.command)) plan.installs.push(step.install);
-    if (step.warning) plan.warnings.push(`${relative2(root, edit.path)}: ${step.warning}`);
-  }
-  plan.install = plan.installs.length === 1 ? plan.installs[0] : null;
-  if (!tracked) plan.warnings.push("No Git repository: review the changed text files before installing.");
-  return plan;
-}
-function atomicWrite(path, text, mode) {
-  const temporary = `${path}.${randomUUID()}.migrate`;
-  try {
-    writeFileSync2(temporary, text, { flag: "wx", mode });
-    renameSync(temporary, path);
-  } finally {
-    if (existsSync3(temporary)) unlinkSync(temporary);
-  }
-}
-function apply(plan) {
-  for (const edit of plan.edits) if (!(edit.gitExclude ? lstatSync(edit.path).isFile() && !lstatSync(edit.path).isSymbolicLink() : safeFile(plan.root, edit.path)) || readFileSync2(edit.path, "utf8") !== edit.before) throw new Error(`File changed during migration: ${relative2(plan.root, edit.path)}. Run the preview again.`);
-  for (const move of plan.moves) if (present(move.to) || lstatSync(move.from).isSymbolicLink()) throw new Error(`Directory changed during migration: ${relative2(plan.root, move.from)}.`);
-  const written = [], moved = [];
-  try {
-    for (const [hash, contents] of plan.blobs) if (git(plan.root, ["hash-object", "--no-filters", "-w", "--stdin"], contents) !== hash) throw new Error("Could not preserve a variant merge base.");
-    for (const edit of plan.edits) {
-      atomicWrite(edit.path, edit.after, edit.mode);
-      written.push(edit);
-    }
-    for (const move of plan.moves) {
-      renameSync(move.from, move.to);
-      moved.push(move);
-    }
-  } catch (error) {
-    for (const move of moved.reverse()) renameSync(move.to, move.from);
-    for (const edit of written.reverse()) atomicWrite(edit.path, edit.before, edit.mode);
-    throw error;
-  }
-}
-function runMigrate(args, io) {
-  if (args.some((arg) => arg === "--help" || arg === "-h")) {
-    out(io, "Usage: isotone migrate [--write] [--json] [--manager npm|pnpm|yarn|bun]");
-    out(io, "Preview migration from iso-iterate. --write applies it; installing remains an explicit next step.");
-    return 0;
-  }
-  if (parseArgs(args, ["--manager"], ["--write", "--json"]).length) throw new Error("migrate does not take positional arguments.");
-  const manager = valueFor(args, "--manager");
-  if (manager && !["npm", "pnpm", "yarn", "bun"].includes(manager)) throw new Error("--manager must be npm, pnpm, yarn or bun.");
-  const plan = planMigration(io.cwd, manager);
-  const write = args.includes("--write");
-  const changed = plan.edits.length > 0 || plan.moves.length > 0;
-  if (write && !plan.conflicts.length) apply(plan);
-  const summary = {
-    root: plan.root,
-    version,
-    applied: write && !plan.conflicts.length && changed,
-    edits: plan.edits.map((edit) => relative2(plan.root, edit.path)),
-    moves: plan.moves.map((move) => ({ from: relative2(plan.root, move.from), to: relative2(plan.root, move.to) })),
-    conflicts: plan.conflicts,
-    warnings: plan.warnings,
-    install: changed ? plan.install : null,
-    installs: changed ? plan.installs : []
-  };
-  if (args.includes("--json")) out(io, JSON.stringify(summary, null, 2));
-  else {
-    out(io, `${plan.conflicts.length ? "Blocked" : write ? "Applied" : "Preview"}: ${plan.root}`);
-    for (const file of summary.edits) out(io, `  edit ${file}`);
-    for (const move of summary.moves) out(io, `  move ${move.from} \u2192 ${move.to}`);
-    for (const message of [...plan.conflicts, ...plan.warnings]) out(io, message);
-    if (!changed && !plan.conflicts.length) out(io, "No migration changes needed.");
-    else if (!write && !plan.conflicts.length) out(io, "Review this plan, then run isotone migrate --write.");
-    if (!plan.conflicts.length) for (const step of summary.installs) out(io, `After applying, run ${step.command} from ${step.cwd}, then restart the dev server. Lockfiles and feedback are unchanged by migration.`);
-  }
-  return plan.conflicts.length ? 1 : 0;
-}
-
 // src/cli/run.ts
 async function runCli(argv, ioInput = {}) {
   const io = makeIo(ioInput);
   try {
-    if (argv[0] === "migrate") return runMigrate(argv.slice(1), io);
     if (argv[0] === "check-update") return await runCheckUpdate(argv.slice(1), io);
     if (argv[0] === "serve") return await runServe(argv.slice(1), io);
     if (argv[0] === "variant") return await runVariant(argv.slice(1), io);
@@ -1100,7 +802,6 @@ function printHelp(io) {
   out(io);
   out(io, "Setting a repo up");
   out(io, "  isotone init [--approach overlay|host|serve] [--yes] [--json]");
-  out(io, "  isotone migrate [--write] [--json] [--manager npm|pnpm|yarn|bun]");
 }
 async function runServe(args, io) {
   const { serveIteration, DEFAULT_PORT } = await import("./serve.js");
@@ -1116,7 +817,7 @@ async function runServe(args, io) {
     errOut(io, error.message);
     return 1;
   }
-  const file = resolve3(io.cwd, valueFor(args, "--file") ?? ".iteration-feedback.json");
+  const file = resolve2(io.cwd, valueFor(args, "--file") ?? ".iteration-feedback.json");
   const port = Number(valueFor(args, "--port") ?? DEFAULT_PORT);
   const host = valueFor(args, "--host");
   const theme = valueFor(args, "--theme") ?? "auto";
@@ -1170,7 +871,7 @@ function runNotes(argv, io) {
     errOut(io, "--days must be a positive number.");
     return 1;
   }
-  const file = resolve3(io.cwd, valueFor(argv, "--file") ?? ".iteration-feedback.json");
+  const file = resolve2(io.cwd, valueFor(argv, "--file") ?? ".iteration-feedback.json");
   const all = has(argv, "--all");
   const doneIdx = argv.indexOf("--done");
   const undoneIdx = argv.indexOf("--undone");