@anja.codes/vitakit 0.1.0 → 0.3.0

package/dist/chunks/fields.mjs

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { v as visibility, t as text, a as richText, d as dateRange, u as url, b as absoluteUrl, l as linked, r as requiredLink } from '../shared/vitakit.DvABWuUc.mjs';
+import '../shared/vitakit.DCK90zq4.mjs';
+import 'node:url';
+import '../shared/vitakit.D10HyDhF.mjs';
+
+const FIELD_TYPE_NAMES = {
+  "text": "text",
+  "formatted-text": "formatted text",
+  "number": "number",
+  "yes-no": "yes/no",
+  "date": "date",
+  "web-address": "web address",
+  "link": "link",
+  "choice": "one of a fixed list",
+  "group": "group of fields",
+  "custom": "custom"
+};
+const PRIMITIVES = /* @__PURE__ */ new Map([
+  [text, "text"],
+  [richText, "formatted-text"],
+  [dateRange, "date"],
+  [url, "web-address"],
+  [absoluteUrl, "web-address"],
+  [linked, "link"],
+  [requiredLink, "link"]
+]);
+function describeField(path, schema) {
+  let current = schema;
+  let optional = false;
+  let several = false;
+  let fallback;
+  let hasDefault = false;
+  for (; ; ) {
+    if (PRIMITIVES.has(current)) break;
+    if (current instanceof z.ZodOptional || current instanceof z.ZodNullable) {
+      optional = true;
+      current = current.unwrap();
+    } else if (current instanceof z.ZodDefault) {
+      optional = true;
+      hasDefault = true;
+      fallback = current.def.defaultValue;
+      current = current.unwrap();
+    } else if (current instanceof z.ZodArray && !several) {
+      several = true;
+      current = current.element;
+    } else {
+      break;
+    }
+  }
+  const description = { path, type: "custom", optional, several };
+  if (hasDefault) description.default = fallback;
+  const primitive = PRIMITIVES.get(current);
+  if (primitive) description.type = primitive;
+  else if (current instanceof z.ZodString) description.type = "text";
+  else if (current instanceof z.ZodNumber) description.type = "number";
+  else if (current instanceof z.ZodBoolean) description.type = "yes-no";
+  else if (current instanceof z.ZodEnum) {
+    description.type = "choice";
+    description.choices = current.options.map(String);
+  } else if (current instanceof z.ZodObject) {
+    description.type = "group";
+    description.fields = Object.entries(current.shape).map(([name, field]) => describeField(`${path}.${name}`, field));
+  }
+  return description;
+}
+function describeSection(schema) {
+  if (!(schema instanceof z.ZodArray) || !(schema.element instanceof z.ZodObject)) return void 0;
+  return Object.entries(schema.element.shape).filter(([name, field]) => !(name === "visibility" && field === visibility)).map(([name, field]) => describeField(name, field));
+}
+function fieldSummary(field) {
+  const type = field.type === "choice" && field.choices ? `one of ${field.choices.join(", ")}` : FIELD_TYPE_NAMES[field.type];
+  return [
+    field.several ? `list of ${type}` : type,
+    field.optional ? field.default !== void 0 ? `default ${JSON.stringify(field.default)}` : "optional" : "required"
+  ].join(", ");
+}
+
+export { FIELD_TYPE_NAMES, describeField, describeSection, fieldSummary };

package/dist/chunks/inventory.mjs

@@ -0,0 +1,201 @@
+import { readFile, stat, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import matter from 'gray-matter';
+import { parse } from 'yaml';
+import { l as loadContent } from '../shared/vitakit.DteA9vLy.mjs';
+import { describeSection } from './fields.mjs';
+import { findSectionFiles, resolveSectionSchema } from './sections.mjs';
+import { schemas } from './schemas.mjs';
+import { findDocuments, documentSectionProblems } from './documents.mjs';
+import { a as pageRoute, d as documentDirective, p as publicationPlacementProblems, b as findWebPlacements } from '../shared/vitakit.DvvUYUTS.mjs';
+import { m as messageOf, w as whereOf } from '../shared/vitakit.DCK90zq4.mjs';
+import './bibliography.mjs';
+import '../shared/vitakit.DQ6PmGoL.mjs';
+import 'node:url';
+import '@behackl/citation-js-extras';
+import 'unified';
+import 'rehype-parse';
+import 'rehype-sanitize';
+import 'rehype-stringify';
+import 'remark-parse';
+import 'remark-gfm';
+import 'remark-math';
+import 'remark-rehype';
+import 'rehype-katex';
+import 'rehype-raw';
+import 'unist-util-visit';
+import 'zod';
+import './publication-lists.mjs';
+import '../shared/vitakit.D10HyDhF.mjs';
+import '../shared/vitakit.DvABWuUc.mjs';
+import '../shared/vitakit.TSMTC5Jl.mjs';
+import '../shared/vitakit.D-DdJaDZ.mjs';
+
+const posix = (path) => path.split(sep).join("/");
+async function files(dir, filter) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  const found = [];
+  for (const entry of entries) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) found.push(...await files(path, filter));
+    else if (filter(entry.name)) found.push(path);
+  }
+  return found.sort();
+}
+async function newest(paths) {
+  let latest = 0;
+  for (const path of paths) {
+    const info = await stat(path).catch(() => void 0);
+    if (info && info.mtimeMs > latest) latest = info.mtimeMs;
+  }
+  return latest;
+}
+function sharedSchema(source) {
+  return /export\s*\{\s*default\s*\}\s*from\s*['"]\.\/([a-z0-9-]+)(?:\.ts)?['"]/.exec(source)?.[1] ?? /^export\s+default\s+schemas\.([a-z]\w*)\s*;?\s*$/m.exec(source)?.[1];
+}
+function belongsTo(problem, file) {
+  return problem.where === file.where || problem.where === `schemas/${file.id}.ts`;
+}
+async function inventory(rootDir, options = {}) {
+  const content = await loadContent(rootDir, { strict: false, maxVisibility: "private" });
+  const problems = [...content.issues];
+  const { files: sectionFiles } = await findSectionFiles(rootDir).catch(() => ({ files: [] }));
+  const sections = [];
+  const schemasForDocuments = [];
+  for (const file of sectionFiles) {
+    const local = join(rootDir, "schemas", `${file.id}.ts`);
+    const builtIn = Object.hasOwn(schemas, file.id);
+    const section = {
+      id: file.id,
+      where: file.where,
+      schema: { origin: existsSync(local) ? "local" : builtIn ? "built-in" : "none" },
+      problems: problems.filter((problem) => belongsTo(problem, file))
+    };
+    if (section.schema.origin === "local") {
+      section.schema.file = `schemas/${file.id}.ts`;
+      const source = await readFile(local, "utf8");
+      const shared = sharedSchema(source);
+      if (shared) section.schema.sharedWith = shared;
+      if (builtIn && /\bextendSection\s*\(\s*schemas\.[\w$]+/.test(source)) section.schema.extendsBuiltIn = true;
+    }
+    try {
+      const raw = parse(await readFile(file.file, "utf8"));
+      if (Array.isArray(raw)) section.entries = raw.length;
+      else if (raw === null) section.entries = 0;
+    } catch {
+    }
+    if (section.schema.origin !== "none") {
+      try {
+        const source = await resolveSectionSchema(rootDir, file);
+        schemasForDocuments.push({ id: file.id, schema: source.schema });
+        const fields = describeSection(source.schema);
+        if (fields) section.fields = fields;
+      } catch {
+      }
+    }
+    if (!section.problems.length) {
+      const counts = { public: 0, cv: 0, private: 0 };
+      for (const entry of content.sections[file.id] ?? []) counts[entry.visibility]++;
+      section.counts = counts;
+    }
+    sections.push(section);
+  }
+  const menu = new Set(content.profile.nav.map((item) => item.url));
+  const pages = /* @__PURE__ */ new Map();
+  const page = (route) => {
+    if (!pages.has(route)) pages.set(route, { route, inMenu: menu.has(route) });
+    return pages.get(route);
+  };
+  const pagesDir = join(rootDir, "content", "pages");
+  for (const path of await files(pagesDir, (name) => name.endsWith(".md"))) {
+    const slug = relative(pagesDir, path).replace(/\.md$/, "");
+    let route = slug === "index" ? "/" : `/${slug}/`;
+    let title;
+    try {
+      const { data } = matter(await readFile(path, "utf8"));
+      if (typeof data.route === "string") route = data.route;
+      if (typeof data.title === "string") title = data.title;
+    } catch {
+    }
+    Object.assign(page(route), { markdown: posix(relative(rootDir, path)), ...title ? { title } : {} });
+  }
+  let catchAll;
+  const vuePagesDir = join(rootDir, "app", "pages");
+  for (const path of await files(vuePagesDir, (name) => name.endsWith(".vue"))) {
+    const below = relative(vuePagesDir, path);
+    if (below.includes("[")) {
+      if (/\[\.\.\.[^\]]+\]\.vue$/.test(below) && !below.includes(sep)) catchAll = posix(relative(rootDir, path));
+      continue;
+    }
+    page(pageRoute(below)).vue = posix(relative(rootDir, path));
+  }
+  const bib = await readFile(join(rootDir, "content", "publications.bib"), "utf8").catch(() => void 0);
+  const publications = bib === void 0 ? void 0 : {
+    file: "content/publications.bib",
+    // Counted, not parsed: the lists were parsed above, and may be broken.
+    entries: bib.match(/^\s*@(?!comment\b|string\b|preamble\b)\w+\s*[{(]/gim)?.length ?? 0,
+    counts: Object.fromEntries(Object.entries(content.publications).map(([name, list]) => [name, list.count]))
+  };
+  const cvDir = join(rootDir, "cv-tex");
+  const { documents: found, problems: documentProblems } = await findDocuments(cvDir);
+  problems.push(...documentProblems);
+  const known = /* @__PURE__ */ new Set([...sections.map((section) => section.id), "profile"]);
+  const lists = Object.keys(content.publications);
+  const documents = [];
+  for (const document of found) {
+    const tex = `cv-tex/${document.name}.tex`;
+    const source = await readFile(document.texFile, "utf8");
+    const pdfPath = join(cvDir, `${document.name}.pdf`);
+    const pdf = await stat(pdfPath).catch(() => void 0);
+    const own = documentSectionProblems(document, schemasForDocuments);
+    const directive = documentDirective(source);
+    if (!directive) own.push({ where: tex, message: `has no \\vitadocument{${document.name}}` });
+    else if (directive.name !== document.name) {
+      own.push({ where: `${tex}:${directive.line}`, message: `\\vitadocument{${directive.name}} does not match the file name; expected \\vitadocument{${document.name}}` });
+    }
+    const { placements } = document;
+    for (const placement of placements) {
+      if (!known.has(placement.section) && placement.section !== "publications") {
+        own.push({ where: `${tex}:${placement.line}`, message: `no section called "${placement.section}"` });
+      }
+    }
+    own.push(...publicationPlacementProblems([], [...placements, ...document.publications], lists));
+    problems.push(...own);
+    documents.push({
+      name: document.name,
+      tex,
+      ...existsSync(join(cvDir, `${document.name}.yml`)) ? { yml: `cv-tex/${document.name}.yml` } : {},
+      options: document.options,
+      placements,
+      publications: document.publications,
+      ...pdf ? { pdf: { file: `cv-tex/${document.name}.pdf`, mtimeMs: pdf.mtimeMs } } : {},
+      problems: [...documentProblems.filter((problem) => problem.where === `cv-tex/${document.name}.yml`), ...own]
+    });
+  }
+  const sourcesMtimeMs = await newest([
+    ...await files(join(rootDir, "content"), () => true),
+    ...await files(join(rootDir, "schemas"), () => true),
+    ...await files(cvDir, (name) => /\.(tex|yml|yaml|eta|cls)$/.test(name)).then((list) => list.filter((path) => !relative(cvDir, path).startsWith("generated")))
+  ]);
+  const none = () => ({ placements: [], publications: [], dynamic: [], components: /* @__PURE__ */ new Map() });
+  const web = options.web === false ? none() : await findWebPlacements(rootDir).catch((error) => {
+    problems.push({ where: whereOf(error, "app/"), message: messageOf(error) });
+    return none();
+  });
+  problems.push(...publicationPlacementProblems(web.publications, [], lists));
+  return {
+    root: rootDir,
+    sections,
+    pages: [...pages.values()].sort((a, b) => a.route.localeCompare(b.route)),
+    ...catchAll ? { catchAll } : {},
+    ...publications ? { publications } : {},
+    documents,
+    web,
+    sourcesMtimeMs,
+    problems,
+    content
+  };
+}
+
+export { inventory };

package/dist/chunks/migrations.mjs

@@ -0,0 +1,218 @@
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+import { parseExpression } from '@babel/parser';
+import { parse, parseDocument, isMap, isScalar } from 'yaml';
+import { l as loadPublicationsSchema, d as defaultPublications } from './bibliography.mjs';
+import { i as importProjectModule } from '../shared/vitakit.DCK90zq4.mjs';
+import { addPublicationList, publicationListYaml } from './yaml.mjs';
+import { r as renamePublicationsSettings } from '../shared/vitakit.CCTDg7pz.mjs';
+import { publicationsElements } from './vue.mjs';
+import { f as findPdfPlacements } from '../shared/vitakit.DvvUYUTS.mjs';
+import { LISTS_FILE, LISTS_HEADER } from './publication-lists.mjs';
+import 'node:fs';
+import '../shared/vitakit.DQ6PmGoL.mjs';
+import 'node:url';
+import '@behackl/citation-js-extras';
+import 'unified';
+import 'rehype-parse';
+import 'rehype-sanitize';
+import 'rehype-stringify';
+import 'remark-parse';
+import 'remark-gfm';
+import 'remark-math';
+import 'remark-rehype';
+import 'rehype-katex';
+import 'rehype-raw';
+import 'unist-util-visit';
+import 'zod';
+import '../shared/vitakit.UfoXdL7U.mjs';
+import '@vue/compiler-sfc';
+
+class ListPlan {
+  constructor(existing) {
+    this.existing = existing;
+  }
+  added = /* @__PURE__ */ new Map();
+  /** The name of a list with these settings: an existing one, or a new one. */
+  name(wanted, settings) {
+    const same = (other) => JSON.stringify(other ?? {}) === JSON.stringify(settings);
+    for (const [name2, other] of [...Object.entries(this.existing), ...this.added]) if (same(other)) return name2;
+    let name = wanted;
+    for (let index = 2; Object.hasOwn(this.existing, name) || this.added.has(name); index++) name = `${wanted}-${index}`;
+    this.added.set(name, settings);
+    return name;
+  }
+}
+function statusList(statuses, grouped = true) {
+  return {
+    wanted: `${statuses?.join("-") ?? "all"}${grouped ? "" : "-ungrouped"}`,
+    settings: {
+      ...statuses ? { where: { status: statuses.length === 1 ? statuses[0] : statuses } } : {},
+      ...grouped ? { groupBy: "status" } : {}
+    }
+  };
+}
+function literalStrings(expression) {
+  try {
+    const node = parseExpression(expression);
+    if (node.type !== "ArrayExpression") return void 0;
+    const values = node.elements.map((element) => element?.type === "StringLiteral" ? element.value : void 0);
+    return values.every((value) => value !== void 0) ? values : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function legacyList(element, statuses) {
+  const groupsProp = element.props.find((prop) => prop.name === "groups");
+  const headingsProp = element.props.find((prop) => prop.name === "headings");
+  const groups = groupsProp?.expression !== void 0 ? literalStrings(groupsProp.expression) : void 0;
+  if (groupsProp && !groups) return { reason: "its groups are not a literal list such as ['preprint']" };
+  const headings = !headingsProp || headingsProp.expression === "true" || headingsProp.expression === void 0 && headingsProp.value === void 0;
+  if (headingsProp && !headings && headingsProp.expression !== "false") return { reason: "its headings are not literally true or false" };
+  const list = statusList(groups, headings);
+  const reordered = headings && groups && groups.join() !== statuses.filter((status) => groups.includes(status)).join();
+  const merged = !headings && (groups?.length ?? 2) > 1;
+  const note = reordered ? "its groups now appear in the order of the statuses in schemas/publications.ts" : merged ? "it is now one list, newest first, rather than one status after the other" : void 0;
+  return { ...list, ...note ? { note } : {} };
+}
+async function statusOrder(root) {
+  const ids = (statuses) => statuses.map((status) => status.id);
+  try {
+    return ids((await loadPublicationsSchema(root)).statuses);
+  } catch {
+    const path = join(root, "schemas", "publications.ts");
+    const old = await stat(path).then((info) => importProjectModule(path, info.mtimeMs, "schemas/publications.ts")).then((module) => module.default?.groups, () => void 0);
+    return Array.isArray(old) ? ids(old) : ids(defaultPublications.statuses);
+  }
+}
+async function vueFiles(root, dir = join(root, "app")) {
+  const files = [];
+  for (const entry of await readdir(dir, { withFileTypes: true }).catch(() => [])) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...await vueFiles(root, path));
+    else if (entry.name.endsWith(".vue")) files.push(relative(root, path).split(sep).join("/"));
+  }
+  return files.sort();
+}
+async function migrateSchema(ws, notes) {
+  const path = "schemas/publications.ts";
+  const source = await ws.read(path);
+  if (source === void 0 || !/\b(groups|defaultGroup)\s*:/.test(source)) return;
+  const renamed = renamePublicationsSettings(source, { groups: "statuses", defaultGroup: "defaultStatus" });
+  if (!renamed.ok) notes.after.push(`By hand: in ${path}, rename groups to statuses and defaultGroup to defaultStatus (${renamed.reason}).`);
+  else if (renamed.value !== source) await ws.edit(path, renamed.value, "groups is now statuses, defaultGroup defaultStatus");
+}
+async function migratePages(root, ws, lists, notes) {
+  const statuses = await statusOrder(root);
+  for (const path of await vueFiles(root)) {
+    const source = await ws.read(path);
+    if (/(^|\/)VitaPublications\.vue$/.test(path)) {
+      notes.after.push(`By hand: ${path} is your copy of VitaPublications. Its props are now list and title, and it reads usePublicationList(list); \`vitakit eject VitaPublications\` shows vitakit's.`);
+    }
+    if (/\busePublications\s*\(/.test(source)) {
+      notes.after.push(`By hand: ${path} calls usePublications(); use usePublicationList('<list>') with a list from ${LISTS_FILE}.`);
+    }
+    const found = publicationsElements(source);
+    if (!found.ok) {
+      if (source.includes("VitaPublications")) notes.after.push(`By hand: ${path} ${found.reason}; check its VitaPublications.`);
+      continue;
+    }
+    const edits = [];
+    const shown = [];
+    for (const element of found.value) {
+      if (element.props.some((prop) => prop.name === "list")) continue;
+      const old = element.props.filter((prop) => prop.name === "groups" || prop.name === "headings");
+      const legacy = old.length ? legacyList(element, statuses) : statusList();
+      if ("reason" in legacy) {
+        notes.after.push(`By hand: ${path}:${element.line}: ${legacy.reason}. Declare the list in ${LISTS_FILE} and write <VitaPublications list="<name>" />.`);
+        continue;
+      }
+      const name = lists.name(legacy.wanted, legacy.settings);
+      for (const prop of old) {
+        let start = prop.start;
+        while (start > 0 && /\s/.test(source[start - 1])) start--;
+        edits.push({ start, end: prop.end, text: "" });
+      }
+      const afterTag = element.start + 1 + element.tag.length;
+      edits.push({ start: afterTag, end: afterTag, text: ` list="${name}"` });
+      shown.push(name);
+      if ("note" in legacy && legacy.note) notes.before.push(`${path}:${element.line} shows the list ${name}: ${legacy.note}.`);
+    }
+    if (!edits.length) continue;
+    let result = source;
+    for (const edit of edits.sort((a, b) => b.start - a.start)) result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+    await ws.edit(path, result, `VitaPublications shows ${[...new Set(shown)].join(", ")}`);
+  }
+}
+async function migrateDocuments(root, ws, lists, notes) {
+  const files = (await readdir(join(root, "cv-tex")).catch(() => [])).filter((name) => name.endsWith(".tex")).sort();
+  for (const file of files) {
+    const tex = `cv-tex/${file}`;
+    const yml = tex.replace(/\.tex$/, ".yml");
+    let list = statusList();
+    const options = await ws.read(yml);
+    const document = options === void 0 ? void 0 : parseDocument(options);
+    const pair = document && isMap(document.contents) ? document.contents.items.find((item) => isScalar(item.key) && item.key.value === "publications") : void 0;
+    if (options !== void 0 && pair) {
+      const groups = document.toJS().publications?.groups;
+      if (Array.isArray(groups) && groups.every((group) => typeof group === "string")) list = statusList(groups);
+      const start = pair.key.range?.[0];
+      const end = pair.value?.range?.[1];
+      if (start === void 0 || end === void 0) {
+        notes.after.push(`By hand: remove publications from ${yml}; which publications the PDF shows is now a list.`);
+      } else {
+        const lines2 = options.split("\n");
+        const lineOf = (offset) => options.slice(0, offset).split("\n").length;
+        lines2.splice(lineOf(start) - 1, lineOf(Math.max(start, end - 1)) - lineOf(start) + 1);
+        await ws.edit(yml, lines2.join("\n"), `publications are now a list in ${LISTS_FILE}`);
+      }
+    }
+    const source = await ws.read(tex);
+    const inputs = findPdfPlacements("", tex, source).filter((placement) => placement.macro === "vitainput" && placement.section === "publications");
+    if (!inputs.length) continue;
+    const name = lists.name(list.wanted, list.settings);
+    const lines = source.split("\n");
+    for (const input of [...inputs].reverse()) {
+      const index = input.line - 1;
+      const heading = index > 0 ? /^\s*\\section\{([^{}]*)\}\s*$/.exec(lines[index - 1])?.[1] : void 0;
+      lines[index] = lines[index].replace("\\vitainput{publications}", `\\vitapublications${heading !== void 0 ? `[${heading}]` : ""}{${name}}`);
+      if (heading !== void 0) lines.splice(index - 1, 1);
+    }
+    await ws.edit(tex, lines.join("\n"), `shows the publication list ${name}`);
+    notes.before.push(`${tex} shows the list ${name}: in the PDF too, publications now come in the list's order, as on the website (biblatex sorted them by year and author before), and each group is numbered from 1.`);
+  }
+  if (await ws.read("cv-tex/templates/publications.eta") !== void 0) {
+    notes.after.push("By hand: cv-tex/templates/publications.eta is your copy of the PDF template. vitakit's now cites a list in its order, with `<%~ it.bib.cite() %>` instead of `\\nocite{*}`, inside `\\begin{refcontext}[sorting=none]`.");
+  }
+}
+async function migratePublicationLists(root, ws, notes) {
+  await migrateSchema(ws, notes);
+  const source = await ws.read(LISTS_FILE);
+  let existing;
+  try {
+    existing = source === void 0 ? {} : parse(source) ?? {};
+  } catch {
+    notes.after.push(`By hand: ${LISTS_FILE} cannot be read; fix it, then run \`vitakit migrate\` again.`);
+    return;
+  }
+  const lists = new ListPlan(typeof existing === "object" && !Array.isArray(existing) ? existing : {});
+  await migratePages(root, ws, lists, notes);
+  await migrateDocuments(root, ws, lists, notes);
+  if (!lists.added.size) return;
+  let lines = source ?? LISTS_HEADER;
+  for (const [name, settings] of lists.added) {
+    const added = addPublicationList(lines, name, settings);
+    if (!added.ok) {
+      notes.after.push(`By hand: add to ${LISTS_FILE} (${added.reason}):
+${[...lists.added].map(([other, value]) => publicationListYaml(other, value)).join("\n")}`);
+      return;
+    }
+    lines = added.value;
+  }
+  notes.after.push(`The new lists are named after what they show. To rename one, change its name in ${LISTS_FILE} and where it is shown.`);
+  const reason = `declares ${[...lists.added.keys()].join(", ")}`;
+  if (source === void 0) ws.create(LISTS_FILE, lines, reason, { show: true });
+  else await ws.edit(LISTS_FILE, lines, reason);
+}
+
+export { migratePublicationLists };

package/dist/chunks/plan.mjs

@@ -0,0 +1,172 @@
+import { existsSync } from 'node:fs';
+import { readFile, mkdir, writeFile, rename } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { C as CommandError } from '../shared/vitakit.zwr1ssO5.mjs';
+import '../shared/vitakit.DQ6PmGoL.mjs';
+import 'node:url';
+import 'node:process';
+import 'node:util';
+import 'node:readline/promises';
+
+const writes = (plan) => plan.items.filter((item) => item.kind === "create" || item.kind === "replace" || item.kind === "edit");
+function diff(before, after, context = 2) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const midA = a.slice(start, endA);
+  const midB = b.slice(start, endB);
+  const ops = a.slice(0, start).map((line) => ({ kind: " ", line }));
+  if (midA.length * midB.length > 1e6) {
+    ops.push(...midA.map((line) => ({ kind: "-", line })), ...midB.map((line) => ({ kind: "+", line })));
+  } else {
+    const lengths = Array.from({ length: midA.length + 1 }, () => new Array(midB.length + 1).fill(0));
+    for (let i2 = midA.length - 1; i2 >= 0; i2--) {
+      for (let j2 = midB.length - 1; j2 >= 0; j2--) {
+        lengths[i2][j2] = midA[i2] === midB[j2] ? lengths[i2 + 1][j2 + 1] + 1 : Math.max(lengths[i2 + 1][j2], lengths[i2][j2 + 1]);
+      }
+    }
+    let i = 0;
+    let j = 0;
+    while (i < midA.length || j < midB.length) {
+      if (i < midA.length && j < midB.length && midA[i] === midB[j]) {
+        ops.push({ kind: " ", line: midA[i] });
+        i++;
+        j++;
+      } else if (i < midA.length && (j === midB.length || lengths[i + 1][j] >= lengths[i][j + 1])) {
+        ops.push({ kind: "-", line: midA[i++] });
+      } else {
+        ops.push({ kind: "+", line: midB[j++] });
+      }
+    }
+  }
+  ops.push(...a.slice(endA).map((line) => ({ kind: " ", line })));
+  const shown = ops.map((op, index) => op.kind !== " " || ops.slice(Math.max(0, index - context), index + context + 1).some((near) => near.kind !== " "));
+  const lines = [];
+  ops.forEach((op, index) => {
+    if (!shown[index]) return;
+    if (lines.length && !shown[index - 1]) lines.push("    \u2026");
+    lines.push(`  ${op.kind === " " ? " " : op.kind} ${op.line}`);
+  });
+  return lines;
+}
+function printPlan(io, style, plan) {
+  const lines = [];
+  for (const item of plan.items) {
+    if (item.kind === "create") {
+      lines.push(`${style.green("+")} ${item.path}   ${style.dim(item.reason)}`);
+      if (item.show) lines.push(...item.content.trimEnd().split("\n").map((line) => style.dim(`    ${line}`)));
+    } else if (item.kind === "replace") {
+      lines.push(`${style.yellow("!")} ${item.path}   ${style.dim(item.reason)}`);
+      if (item.show) lines.push(...item.content.trimEnd().split("\n").map((line) => style.dim(`    ${line}`)));
+    } else if (item.kind === "keep") lines.push(`${style.dim("=")} ${item.path}   ${style.dim(item.reason)}`);
+    else if (item.kind === "edit") {
+      lines.push(`${style.yellow("~")} ${item.path}   ${style.dim(item.reason)}`);
+      lines.push(...diff(item.before, item.after).map((line) => line.startsWith("  +") ? style.green(line) : line.startsWith("  -") ? style.red(line) : style.dim(line)));
+    } else {
+      lines.push(`${style.yellow("?")} ${item.path}   ${item.reason}`);
+      lines.push(...item.snippet.split("\n").map((line) => `    ${line}`));
+    }
+  }
+  io.out(`${lines.join("\n")}
+`);
+}
+async function confirmPlan(io, plan, yes) {
+  if (!writes(plan).length || yes) return true;
+  if (!io.interactive) {
+    throw new CommandError("nothing written: confirm with --yes, or only preview with --dry-run");
+  }
+  const answer = (await io.ask("\nWrite these changes? [Y/n] ")).trim().toLowerCase();
+  if (answer === "" || answer === "y" || answer === "yes") return true;
+  io.out("Cancelled; nothing was written.\n");
+  return false;
+}
+function backupPath(path) {
+  let candidate = `${path}.backup`;
+  for (let index = 2; existsSync(candidate); index++) candidate = `${path}.backup-${index}`;
+  return candidate;
+}
+async function applyPlan(root, plan) {
+  for (const item of writes(plan)) {
+    const path = join(root, item.path);
+    if (item.kind === "create" && existsSync(path)) throw new CommandError(`${item.path} exists now; nothing was written`);
+    if (item.kind !== "create" && !existsSync(path)) throw new CommandError(`${item.path} is gone now; nothing was written`);
+  }
+  const written = [];
+  try {
+    for (const item of writes(plan)) {
+      const path = join(root, item.path);
+      await mkdir(dirname(path), { recursive: true });
+      if (item.kind === "create") await writeFile(path, item.content, { flag: "wx" });
+      else if (item.kind === "replace") {
+        await rename(path, backupPath(path));
+        await writeFile(path, item.content);
+      } else await writeFile(path, item.after);
+      written.push(item.path);
+    }
+  } catch (error) {
+    throw new CommandError(`${error instanceof Error ? error.message : String(error)}${written.length ? `
+  Already written: ${written.join(", ")}` : "\n  Nothing was written."}`);
+  }
+  return written;
+}
+class Workspace {
+  constructor(root) {
+    this.root = root;
+  }
+  items = [];
+  find(path) {
+    return this.items.find((item) => item.path === path && item.kind !== "paste" && item.kind !== "keep");
+  }
+  /** The file as it will be: planned contents first, the disk otherwise. */
+  async read(path) {
+    const planned = this.find(path);
+    if (planned?.kind === "create" || planned?.kind === "replace") return planned.content;
+    if (planned?.kind === "edit") return planned.after;
+    return readFile(join(this.root, path), "utf8").catch(() => void 0);
+  }
+  exists(path) {
+    return Boolean(this.find(path)) || existsSync(join(this.root, path));
+  }
+  /** A new file; `show` prints its contents in the plan, for short files worth reading. */
+  create(path, content, reason, { show = false } = {}) {
+    if (this.exists(path)) throw new CommandError(`${path} exists already; nothing was written`);
+    this.items.push({ kind: "create", path, content, reason, ...show ? { show } : {} });
+  }
+  /** Replace an existing file; the old one is kept as a backup. */
+  replace(path, content, reason, { show = false } = {}) {
+    this.items.push({ kind: "replace", path, content, reason, ...show ? { show } : {} });
+  }
+  /** Change a file; for a file this plan creates, the change becomes part of it. */
+  async edit(path, after, reason) {
+    const planned = this.find(path);
+    if (planned?.kind === "create" || planned?.kind === "replace") {
+      planned.content = after;
+      return;
+    }
+    if (planned?.kind === "edit") {
+      planned.after = after;
+      planned.reason = `${planned.reason}; ${reason}`;
+      return;
+    }
+    const before = await readFile(join(this.root, path), "utf8");
+    this.items.push({ kind: "edit", path, before, after, reason });
+  }
+  keep(path, reason) {
+    this.items.push({ kind: "keep", path, reason });
+  }
+  paste(path, snippet, reason) {
+    this.items.push({ kind: "paste", path, snippet, reason });
+  }
+  plan() {
+    return { items: [...this.items] };
+  }
+}
+
+export { Workspace, applyPlan, backupPath, confirmPlan, diff, printPlan };