hollware 0.9.1 → 0.10.0

package/README.md

@@ -3,8 +3,8 @@
 The command line of [Hollware](https://github.com/hollware/hollware), an open-source headless
 CMS for the agent era, native to Cloudflare Workers.
 
-> **Status: pre-alpha.** `init`, `migrate`, `deploy`, `doctor`, `token`, `invite` and `import`
-> work, against a Hollware that is still being built. POSIX shells only: it has not been tried on
+> **Status: pre-alpha.** `init`, `migrate`, `deploy`, `doctor`, `token`, `invite`, `import` and
+> `export` work, against a Hollware that is still being built. POSIX shells only: it has not been tried on
 > Windows.
 
 ## Commands
@@ -17,12 +17,25 @@ CMS for the agent era, native to Cloudflare Workers.
 | `doctor`  | Check the project, its bindings, its database and its owner, with what to fix    |
 | `token`   | Create, list and revoke personal tokens, and read tokens with `--read`           |
 | `invite`  | Invite a person to the admin, as an editor or an author                          |
-| `import`  | Import Markdown files over MCP, as drafts, and publish them with `--publish`     |
-| `export`  | Export entries as Markdown files (v0.2)                                          |
+| `import`  | Import Markdown over MCP, as drafts; from a Nuxt Content site with `--from`      |
+| `export`  | Export entries over MCP as Markdown files, the layout `import` reads             |
 
 Every command answers `--help`. A command that fails prints one message on stderr, with what to
 do, and exits with code 1.
 
+### Moving a site to Hollware
+
+`import --from nuxt-content` reads the content directory of a Nuxt Content site as the files Hollware
+imports, and validates them all before it writes anything:
+
+```sh
+# With --locale-dirs, content/<locale>/… and the translations of each page
+npx hollware import ./content --from nuxt-content --collection docs --locale-dirs --url https://cms.example.com --token-file ./token.txt
+```
+
+A page keeps its Markdown byte for byte (Comark reads MDC), with its slug as Nuxt Content routes
+it and a `title` from its first heading when it has none.
+
 ## A first run
 
 In a Hollware project (the starter has the D1 binding `DB` in its `wrangler.jsonc`):
@@ -59,11 +72,25 @@ again changes nothing: every entry answers `unchanged`. With `--publish` it publ
 entries that have unpublished changes, and it acknowledges no warning: an entry with warnings is
 reported, and the command exits with code 1. The token never appears in its output.
 
+`export` is its mirror: it writes the entries of the site of the token, as
+`<collection>/<locale>/<slug>.md`, into a directory that must be empty or not exist:
+
+```sh
+hollware export ./backup --url https://cms.example.com --token-file ./token.txt
+hollware export ./live --url https://cms.example.com --token-file ./token.txt --published
+```
+
+Each file is the revision as Hollware keeps it, byte for byte, so importing an export into the
+same site changes nothing. By default it writes the latest revision of every entry, drafts
+included; `--published` writes only the published entries, as they are published. Entries in
+the trash are left out. `--collection` and `--locale` narrow it (repeat them for several),
+`--dry-run` lists the files and writes nothing, and a token with `content:read` is enough.
+
 ## How it works
 
 `init`, `migrate`, `deploy`, `doctor` and `token` run the project's own `wrangler` (the nearest
 `node_modules/.bin/wrangler`) against its D1 database, and read the binding from `wrangler.jsonc`.
-`import` speaks MCP to `<url>/mcp` with the token as a bearer token. The structure of the sites
+`import` and `export` speak MCP to `<url>/mcp` with the token as a bearer token. The structure of the sites
 lives in the database (ADR-033): `init` gives a new site its first definition from a preset, and
 its owner shapes it in the admin, or an agent over MCP.
 

package/dist/export-DprcsjU_.mjs

@@ -0,0 +1,234 @@
+import { i as UsageError, r as CliError, t as printable } from "./format-BpRYEsGB.mjs";
+import { t as readVersion } from "./version-BMhdZaNo.mjs";
+import { t as parseFlags } from "./args-CljWh-kZ.mjs";
+import { a as redact, c as openSession, i as readToken, o as withoutToken, r as mcpEndpoint, s as ToolFailure } from "./import-D9LRrYtb.mjs";
+import { mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { describeSite, getEntry, listEntries, schemas } from "@hollware/core";
+//#region src/commands/export.ts
+const EXPORT_USAGE = [
+	"Usage: hollware export <directory> --url <hollware url> (--token-file <file> | token on stdin)",
+	"                       [--site <key>] [--collection <name>]... [--locale <code>]...",
+	"                       [--published] [--dry-run]",
+	"",
+	"Writes the entries of a running Hollware, read over MCP, as Markdown files at",
+	"<directory>/<collection>/<locale>/<slug>.md: the layout \"hollware import\" reads. Each file is",
+	"the revision byte for byte as Hollware keeps it, frontmatter included, so an import of the",
+	"export into the same site changes nothing. Entries in the trash are left out. The directory",
+	"must be empty or not exist: nothing of yours is overwritten.",
+	"",
+	"Options:",
+	"  --url <url>          The address of your Hollware, such as https://cms.example.com (MCP is at <url>/mcp)",
+	"  --token-file <file>  A file with a personal token; without it, the token is read from stdin",
+	"  --site <key>         Stop unless the token is of this site (a token reads the one site it is of)",
+	"  --collection <name>  Export only this collection; repeat it for several",
+	"  --locale <code>      Export only this locale; repeat it for several",
+	"  --published          Export only the published entries, as they are published; by default the",
+	"                       latest revision of every entry, drafts included",
+	"  --dry-run            List the files it would write, and write nothing",
+	"  --help               Show this help",
+	"",
+	"The token needs content:read."
+].join("\n");
+/** The most entries one `list_entries` answers. */
+const PAGE_SIZE = 100;
+/**
+* A folder name that is safe to write under the directory: no separator, no dot first, nothing a
+* terminal or a file system acts on. Collection names and locales are narrower than this.
+*/
+const SAFE_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9_-]{0,99}$/;
+async function exportContent(argv, io) {
+	const { values, positionals } = parseFlags({
+		args: [...argv],
+		allowPositionals: true,
+		options: {
+			url: { type: "string" },
+			"token-file": { type: "string" },
+			site: { type: "string" },
+			collection: {
+				type: "string",
+				multiple: true
+			},
+			locale: {
+				type: "string",
+				multiple: true
+			},
+			published: { type: "boolean" },
+			"dry-run": { type: "boolean" },
+			help: { type: "boolean" }
+		}
+	});
+	if (values.help === true) {
+		io.out(EXPORT_USAGE);
+		return 0;
+	}
+	const [directory, ...extra] = positionals;
+	if (directory === void 0 || extra.length > 0) throw new UsageError("export takes one directory: hollware export <directory> --url <url>.");
+	if (values.url === void 0) throw new UsageError("--url is required: the address of your Hollware, such as https://cms.example.com.");
+	const endpoint = mcpEndpoint(values.url);
+	const root = resolve(io.cwd, directory);
+	checkTarget(root, directory);
+	const token = await readToken(io, values["token-file"]);
+	try {
+		return await exportEntries({
+			io,
+			token,
+			endpoint,
+			directory,
+			root,
+			site: values.site,
+			collections: values.collection,
+			locales: values.locale,
+			published: values.published === true,
+			dryRun: values["dry-run"] === true
+		});
+	} catch (error) {
+		throw withoutToken(error, token);
+	}
+}
+/** The directory must be empty or not exist, so that the export overwrites nothing. */
+function checkTarget(root, directory) {
+	let names;
+	try {
+		names = readdirSync(root);
+	} catch (error) {
+		const code = error instanceof Error && "code" in error ? error.code : void 0;
+		if (code === "ENOENT") return;
+		if (code === "ENOTDIR") throw new CliError(`${printable(directory)} is not a directory.`);
+		throw new CliError(`could not read ${printable(directory)}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (names.length > 0) throw new CliError(`${printable(directory)} is not empty: export into a new or an empty directory, so that no file is overwritten. Nothing was written.`);
+}
+/**
+* Reads everything first, then writes: a call that fails stops the export before any file is
+* written.
+*/
+async function exportEntries(plan) {
+	const { io, token, directory, root, published, dryRun } = plan;
+	const out = (message) => io.out(redact(message, token));
+	const session = await openSession(plan.endpoint, token, readVersion());
+	let files;
+	let siteKey;
+	try {
+		const { site } = await session.call(describeSite, {});
+		siteKey = site.key;
+		if (plan.site !== void 0 && plan.site !== site.key) throw new CliError(`the token is of the site ${printable(JSON.stringify(site.key))}, not ${printable(JSON.stringify(plan.site))}: a personal token reads the one site it is of. Use a token of ${printable(plan.site)}.`);
+		files = await readAll(session, await listAll(session, chosen("collection", site.collections.map((collection) => collection.name), plan.collections), plan.locales === void 0 ? [void 0] : chosen("locale", site.locales, plan.locales), published), published);
+	} finally {
+		await session.close();
+	}
+	const view = published ? "the published revisions" : "the latest revisions, drafts included";
+	if (files.length === 0) {
+		out(`No entries to export from the site ${printable(siteKey)} (${view}). Nothing was written.`);
+		return 0;
+	}
+	if (dryRun) {
+		out(files.map((file) => `would write  ${printable(file.path)}`).join("\n"));
+		out(`Dry run: ${count(files.length, "entry", "entries")} of the site ${printable(siteKey)} would be written to ${printable(directory)} (${view}):\n${groupSummary(files)}\nNothing was written.`);
+		return 0;
+	}
+	let written = 0;
+	for (const file of files) {
+		const target = join(root, file.collection, file.locale, `${file.slug}.md`);
+		try {
+			mkdirSync(dirname(target), { recursive: true });
+			writeFileSync(target, file.markdown, { flag: "wx" });
+		} catch (error) {
+			throw new CliError(`could not write ${printable(file.path)}: ${error instanceof Error ? error.message : String(error)}. ${written} of ${count(files.length, "file")} written: remove ${printable(directory)} and run the export again.`);
+		}
+		written += 1;
+	}
+	out(`Exported ${count(files.length, "entry", "entries")} of the site ${printable(siteKey)} to ${printable(directory)} (${view}):\n${groupSummary(files)}`);
+	return 0;
+}
+/** The names asked for, each checked against what the site has; all of them when none is. */
+function chosen(kind, available, asked) {
+	if (asked === void 0) return [...available];
+	const unknown = asked.filter((name) => !available.includes(name));
+	if (unknown.length > 0) throw new CliError(`the site has no ${kind} ${unknown.map((name) => printable(JSON.stringify(name))).join(", ")}: it has ${available.map(printable).join(", ")}.`);
+	return [...new Set(asked)];
+}
+/**
+* Every entry of the collections, in the locales (`undefined`: every locale), page by page.
+* The head view leaves out the trash; `published` lists only published entries. An entry whose
+* collection, locale or slug cannot be a file name below the directory stops the export.
+*/
+async function listAll(session, collections, locales, published) {
+	const byPath = /* @__PURE__ */ new Map();
+	for (const collection of collections) for (const locale of locales) {
+		let cursor;
+		do {
+			let page;
+			try {
+				page = await session.call(listEntries, {
+					collection,
+					...locale === void 0 ? {} : { locale },
+					...published ? { status: "published" } : {},
+					limit: PAGE_SIZE,
+					...cursor === void 0 ? {} : { cursor }
+				});
+			} catch (error) {
+				if (!(error instanceof ToolFailure)) throw error;
+				throw new CliError(`could not list ${printable(locale === void 0 ? collection : `${collection}/${locale}`)}: ${sentence(error.message)}. Nothing was written.`);
+			}
+			for (const summary of page.entries) {
+				const path = `${summary.collection}/${summary.locale}/${summary.slug}.md`;
+				if (!SAFE_SEGMENT.test(summary.collection) || !SAFE_SEGMENT.test(summary.locale) || !schemas.slug.safeParse(summary.slug).success) throw new CliError(`the server listed an entry that cannot be a file below the directory: ${printable(JSON.stringify(path))}. Nothing was written.`);
+				byPath.set(path, {
+					collection: summary.collection,
+					locale: summary.locale,
+					slug: summary.slug,
+					path
+				});
+			}
+			cursor = page.nextCursor ?? void 0;
+		} while (cursor !== void 0);
+	}
+	return [...byPath.values()].sort((a, b) => compare(a.collection, b.collection) || compare(a.locale, b.locale) || compare(a.slug, b.slug));
+}
+/** The Markdown of each entry: its latest revision, or the published one. */
+async function readAll(session, listed, published) {
+	const files = [];
+	for (const item of listed) {
+		let answer;
+		try {
+			answer = await session.call(getEntry, {
+				collection: item.collection,
+				locale: item.locale,
+				slug: item.slug,
+				formats: ["markdown"],
+				published
+			});
+		} catch (error) {
+			if (!(error instanceof ToolFailure)) throw error;
+			throw new CliError(`could not read ${printable(item.path)}: ${sentence(error.message)}. Nothing was written.`);
+		}
+		const markdown = answer.entry?.markdown;
+		if (answer.outcome === "not_found" || markdown === void 0) throw new CliError(`${printable(item.path)} is gone: it was ${published ? "unpublished" : "moved to the trash or renamed"} while the export ran. Nothing was written: run the export again.`);
+		files.push({
+			...item,
+			markdown
+		});
+	}
+	return files;
+}
+function sentence(message) {
+	return message.replace(/[\s.]+$/, "");
+}
+function compare(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function count(n, singular, plural = `${singular}s`) {
+	return `${n} ${n === 1 ? singular : plural}`;
+}
+/** One line per collection and locale, with how many entries: `  blog/en: 3`. */
+function groupSummary(files) {
+	const sizes = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const group = `${file.collection}/${file.locale}`;
+		sizes.set(group, (sizes.get(group) ?? 0) + 1);
+	}
+	return [...sizes].map(([group, size]) => `  ${printable(group)}: ${size}`).join("\n");
+}
+//#endregion
+export { exportContent };

package/dist/{import-DG8AABZQ.mjs → import-D9LRrYtb.mjs}

@@ -5,83 +5,6 @@ import { readFileSync, readdirSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { REFUSAL_CONTRACT_IDS, createDraft, getEntry, isPersonalToken, publish, schemas, updateDraft, validate } from "@hollware/core";
 import { Client, InsufficientScopeError, ProtocolError, SdkError, SdkErrorCode, SdkHttpError, StreamableHTTPClientTransport, UnauthorizedError } from "@modelcontextprotocol/client";
-//#region src/import/corpus.ts
-/**
-* Reads the entries of a directory laid out as `<collection>/<locale>/<slug>.md`. Only `.md`
-* files count. A Markdown file at any other depth is skipped and reported; one at the right
-* depth with a slug that is not a slug, or with bytes that are not UTF-8, is a problem. Files
-* and folders whose name starts with a dot, and symbolic links, are never read: a link could
-* lead out of the directory the person pointed at.
-*/
-function readCorpus(root) {
-	const corpus = {
-		files: [],
-		skipped: [],
-		problems: []
-	};
-	walk(root, [], corpus);
-	corpus.files.sort((a, b) => compare(a.collection, b.collection) || compare(a.locale, b.locale) || compare(a.slug, b.slug));
-	corpus.skipped.sort(compare);
-	corpus.problems.sort((a, b) => compare(a.path, b.path));
-	return corpus;
-}
-function compare(a, b) {
-	return a < b ? -1 : a > b ? 1 : 0;
-}
-function walk(directory, segments, corpus) {
-	for (const entry of readdirSync(directory, { withFileTypes: true })) {
-		if (entry.name.startsWith(".")) continue;
-		if (entry.isDirectory()) walk(join(directory, entry.name), [...segments, entry.name], corpus);
-		else if (entry.isFile() && entry.name.endsWith(".md")) readFile(join(directory, entry.name), [...segments, entry.name], corpus);
-	}
-}
-function readFile(file, segments, corpus) {
-	const path = segments.join("/");
-	const [collection, locale, name] = segments;
-	if (segments.length !== 3 || collection === void 0 || locale === void 0 || name === void 0) {
-		corpus.skipped.push(path);
-		return;
-	}
-	const slug = name.slice(0, -3);
-	if (!schemas.slug.safeParse(slug).success) {
-		corpus.problems.push({
-			path,
-			reason: `${JSON.stringify(slug)} is not a slug: use lowercase letters and digits joined by hyphens, up to 200 characters.`
-		});
-		return;
-	}
-	let bytes;
-	try {
-		bytes = readFileSync(file);
-	} catch (error) {
-		corpus.problems.push({
-			path,
-			reason: `the file cannot be read: ${error instanceof Error ? error.message : String(error)}`
-		});
-		return;
-	}
-	let markdown;
-	try {
-		markdown = new TextDecoder("utf-8", {
-			fatal: true,
-			ignoreBOM: true
-		}).decode(bytes);
-	} catch {
-		corpus.problems.push({
-			path,
-			reason: "the file is not valid UTF-8."
-		});
-		return;
-	}
-	corpus.files.push({
-		path,
-		collection,
-		locale,
-		slug,
-		markdown
-	});
-}
-//#endregion
 //#region src/import/session.ts
 /** A tool failed and said so in words, instead of answering with one of its outcomes. */
 var ToolFailure = class extends CliError {
@@ -178,10 +101,176 @@ function explainStatus(error, endpoint) {
 	}
 }
 //#endregion
+//#region src/import/corpus.ts
+/**
+* Reads the entries of a directory laid out as `<collection>/<locale>/<slug>.md`. Only `.md`
+* files count. A Markdown file at any other depth is skipped and reported; one at the right
+* depth with a slug that is not a slug, or with bytes that are not UTF-8, is a problem. Files
+* and folders whose name starts with a dot, and symbolic links, are never read: a link could
+* lead out of the directory the person pointed at.
+*/
+function readCorpus(root) {
+	const corpus = {
+		files: [],
+		skipped: [],
+		problems: []
+	};
+	walk(root, [], corpus);
+	corpus.files.sort((a, b) => compare(a.collection, b.collection) || compare(a.locale, b.locale) || compare(a.slug, b.slug));
+	corpus.skipped.sort(compare);
+	corpus.problems.sort((a, b) => compare(a.path, b.path));
+	return corpus;
+}
+function compare(a, b) {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+function walk(directory, segments, corpus) {
+	for (const entry of readdirSync(directory, { withFileTypes: true })) {
+		if (entry.name.startsWith(".")) continue;
+		if (entry.isDirectory()) walk(join(directory, entry.name), [...segments, entry.name], corpus);
+		else if (entry.isFile() && entry.name.endsWith(".md")) readFile(join(directory, entry.name), [...segments, entry.name], corpus);
+	}
+}
+function readFile(file, segments, corpus) {
+	const path = segments.join("/");
+	const [collection, locale, name] = segments;
+	if (segments.length !== 3 || collection === void 0 || locale === void 0 || name === void 0) {
+		corpus.skipped.push(path);
+		return;
+	}
+	const slug = name.slice(0, -3);
+	if (!schemas.slug.safeParse(slug).success) {
+		corpus.problems.push({
+			path,
+			reason: `${JSON.stringify(slug)} is not a slug: use lowercase letters and digits joined by hyphens, up to 200 characters.`
+		});
+		return;
+	}
+	let bytes;
+	try {
+		bytes = readFileSync(file);
+	} catch (error) {
+		corpus.problems.push({
+			path,
+			reason: `the file cannot be read: ${error instanceof Error ? error.message : String(error)}`
+		});
+		return;
+	}
+	let markdown;
+	try {
+		markdown = new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: true
+		}).decode(bytes);
+	} catch {
+		corpus.problems.push({
+			path,
+			reason: "the file is not valid UTF-8."
+		});
+		return;
+	}
+	corpus.files.push({
+		path,
+		collection,
+		locale,
+		slug,
+		markdown
+	});
+}
+//#endregion
+//#region src/import/from-nuxt-content.ts
+/** The byte order mark a file may start with, kept where it is. */
+const BOM = String.fromCharCode(65279);
+/** A segment of a path as Nuxt Content routes it: its numeric prefix gone. */
+const routed = (segment) => segment.replace(/^\d+\./, "");
+/** The frontmatter of `markdown` with `field` set to `value`, unless the page sets it already. */
+function withField(markdown, field, value) {
+	const line = `${field}: ${JSON.stringify(value)}`;
+	const bom = markdown.startsWith(BOM) ? BOM : "";
+	const body = markdown.slice(bom.length);
+	const open = /^---\r?\n/.exec(body);
+	if (open === null) return `${bom}---\n${line}\n---\n\n${body}`;
+	const close = /^---\s*$/m.exec(body.slice(open[0].length));
+	if (close === null) return markdown;
+	const frontmatter = body.slice(open[0].length, open[0].length + close.index);
+	if (new RegExp(`^${field}\\s*:`, "m").test(frontmatter)) return markdown;
+	const at = open[0].length + close.index;
+	return `${bom}${body.slice(0, at)}${line}\n${body.slice(at)}`;
+}
+function corpusFromNuxtContent(root, options) {
+	const files = [];
+	const skipped = [];
+	const problems = [];
+	const bySlug = /* @__PURE__ */ new Map();
+	const walk = (directory, segments) => {
+		const entries = readdirSync(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+		for (const entry of entries) {
+			if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+			const path = [...segments, entry.name];
+			if (entry.isDirectory()) {
+				walk(join(directory, entry.name), path);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			if (!entry.name.endsWith(".md")) {
+				skipped.push(path.join("/"));
+				continue;
+			}
+			const [first, ...rest] = path;
+			const locale = options.localeDirs ? first ?? "" : options.locale;
+			const below = options.localeDirs ? rest : path;
+			if (options.localeDirs && rest.length === 0) {
+				skipped.push(path.join("/"));
+				continue;
+			}
+			const route = below.map(routed);
+			route[route.length - 1] = (route.at(-1) ?? "").slice(0, -3);
+			if (route.length > 1 && route.at(-1) === "index") route.pop();
+			const slug = route.join("-");
+			const where = path.join("/");
+			if (!schemas.slug.safeParse(slug).success) {
+				problems.push({
+					path: where,
+					reason: `its route makes "${slug}", which is not a slug`
+				});
+				continue;
+			}
+			const key = `${locale}/${slug}`;
+			const other = bySlug.get(key);
+			if (other !== void 0) {
+				problems.push({
+					path: where,
+					reason: `its slug "${slug}" is the slug of ${other} too`
+				});
+				continue;
+			}
+			bySlug.set(key, where);
+			const read = readFileSync(join(directory, entry.name), "utf8");
+			const heading = /^#[ \t]+(.+?)[ \t]*$/m.exec(read)?.[1];
+			const text = withField(read, "title", heading ?? slug);
+			files.push({
+				path: `${options.collection}/${locale}/${slug}.md`,
+				collection: options.collection,
+				locale,
+				slug,
+				markdown: options.localeDirs ? withField(text, options.groupField, slug) : text
+			});
+		}
+	};
+	walk(root, []);
+	const order = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+	files.sort((a, b) => order(a.path, b.path));
+	return {
+		files,
+		skipped: skipped.sort(order),
+		problems: problems.sort((a, b) => order(a.path, b.path))
+	};
+}
+//#endregion
 //#region src/commands/import.ts
 const IMPORT_USAGE = [
 	"Usage: hollware import <directory> --url <hollware url> (--token-file <file> | token on stdin)",
-	"                       [--publish] [--dry-run]",
+	"                       [--publish] [--dry-run] [--from markdown | nuxt-content]",
 	"",
 	"Sends the Markdown files of a directory to a running Hollware over MCP, as drafts. The files",
 	"are <directory>/<collection>/<locale>/<slug>.md. Every file is validated first: if one would be",
@@ -193,6 +282,13 @@ const IMPORT_USAGE = [
 	"  --token-file <file>  A file with a personal token; without it, the token is read from stdin",
 	"  --publish            Then publish the entries that have unpublished changes, acknowledging no warnings",
 	"  --dry-run            Only validate: write nothing, publish nothing",
+	"  --from <source>      What the directory is: markdown (the default), or the content/ of a",
+	"                       Nuxt Content site",
+	"  --collection <name>  nuxt-content: the collection its pages go to",
+	"  --locale <code>      nuxt-content: the locale of every page (default en)",
+	"  --locale-dirs        nuxt-content: the first folder of each page is its locale",
+	"  --group-field <name> nuxt-content: the field of a translation group (default",
+	"                       translationGroup)",
 	"  --help               Show this help",
 	"",
 	"The token needs content:read and content:write, and content:publish for --publish: without it,",
@@ -207,6 +303,11 @@ async function importContent(argv, io) {
 			"token-file": { type: "string" },
 			publish: { type: "boolean" },
 			"dry-run": { type: "boolean" },
+			from: { type: "string" },
+			collection: { type: "string" },
+			locale: { type: "string" },
+			"locale-dirs": { type: "boolean" },
+			"group-field": { type: "string" },
 			help: { type: "boolean" }
 		}
 	});
@@ -214,12 +315,21 @@ async function importContent(argv, io) {
 		io.out(IMPORT_USAGE);
 		return 0;
 	}
+	const from = values.from ?? "markdown";
+	if (from !== "markdown" && from !== "nuxt-content") throw new UsageError(`--from takes markdown or nuxt-content, not "${printable(from)}".`);
+	if (from === "nuxt-content" && values.collection === void 0) throw new UsageError("--from nuxt-content needs --collection: the collection its pages go to.");
 	const [directory, ...extra] = positionals;
 	if (directory === void 0 || extra.length > 0) throw new UsageError("import takes one directory: hollware import <directory> --url <url>.");
 	if (values.url === void 0) throw new UsageError("--url is required: the address of your Hollware, such as https://cms.example.com.");
 	const endpoint = mcpEndpoint(values.url);
 	const root = resolve(io.cwd, directory);
 	if (!isDirectory(root)) throw new CliError(`${directory} is not a directory.`);
+	const corpus = sourceOf(from, root, {
+		collection: values.collection ?? "",
+		locale: values.locale ?? "en",
+		localeDirs: values["locale-dirs"] === true,
+		groupField: values["group-field"] ?? "translationGroup"
+	});
 	const token = await readToken(io, values["token-file"]);
 	try {
 		return await importFiles({
@@ -227,19 +337,29 @@ async function importContent(argv, io) {
 			token,
 			endpoint,
 			directory,
-			root,
+			corpus,
 			publish: values.publish === true,
 			dryRun: values["dry-run"] === true
 		});
 	} catch (error) {
-		if (error instanceof CliError) throw new CliError(redact(error.message, token));
-		const reason = (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ");
-		throw new CliError(`unexpected error: ${redact(printable(reason.slice(0, 300)), token)}. This is a bug in hollware: please report it at https://github.com/hollware/hollware/issues.`);
+		throw withoutToken(error, token);
 	}
 }
-async function importFiles({ io, token, endpoint, directory, root, publish: publishToo, dryRun }) {
+/**
+* What a command that holds the token throws: its own `CliError` without the token, not even in a
+* message of the server, and anything else as one line that says it is a bug.
+*/
+function withoutToken(error, token) {
+	if (error instanceof CliError) return new CliError(redact(error.message, token));
+	const reason = (error instanceof Error ? error.message : String(error)).replace(/\s+/g, " ");
+	return new CliError(`unexpected error: ${redact(printable(reason.slice(0, 300)), token)}. This is a bug in hollware: please report it at https://github.com/hollware/hollware/issues.`);
+}
+/** The files of a directory of Markdown, or of the content/ of a Nuxt Content site. */
+function sourceOf(from, root, options) {
+	return from === "markdown" ? readCorpus(root) : corpusFromNuxtContent(root, options);
+}
+async function importFiles({ io, token, endpoint, directory, corpus, publish: publishToo, dryRun }) {
 	const out = (message) => io.out(redact(message, token));
-	const corpus = readCorpus(root);
 	if (corpus.files.length === 0 && corpus.problems.length === 0) throw new CliError(`no entries in ${directory}: expected Markdown files at <collection>/<locale>/<slug>.md, such as blog/en/hello.md.`);
 	if (corpus.files.length > 0) out(`Found ${count(corpus.files.length, "entry", "entries")} in ${directory} (${collectionSummary(corpus.files)}).`);
 	if (corpus.skipped.length > 0) out(`Skipped ${count(corpus.skipped.length, "Markdown file")} that ${corpus.skipped.length === 1 ? "is" : "are"} not at <collection>/<locale>/<slug>.md: ${listSome(corpus.skipped)}.`);
@@ -297,6 +417,10 @@ function isDirectory(path) {
 		return false;
 	}
 }
+/**
+* The personal token, from `--token-file` (relative to the working directory) or else from stdin,
+* trimmed. Something that is not a personal token is refused, and never printed.
+*/
 async function readToken(io, tokenFile) {
 	let raw;
 	let source;
@@ -543,4 +667,4 @@ function listSome(paths) {
 	return paths.length > shown.length ? `${shown.join(", ")} and ${paths.length - shown.length} more` : shown.join(", ");
 }
 //#endregion
-export { importContent };
+export { redact as a, openSession as c, readToken as i, importContent as n, withoutToken as o, mcpEndpoint as r, ToolFailure as s, IMPORT_USAGE as t };

package/dist/import-JNLtBmyD.mjs

@@ -0,0 +1 @@
+export { n as importContent } from "./import-D9LRrYtb.mjs";

package/dist/index.mjs

@@ -38,7 +38,7 @@ const COMMANDS = [
 	},
 	{
 		name: "export",
-		summary: "Export entries as Markdown files (planned for v0.2, not implemented yet)"
+		summary: "Export entries as Markdown files over MCP"
 	}
 ];
 const NAME_WIDTH = Math.max(...COMMANDS.map((command) => command.name.length));
@@ -77,10 +77,6 @@ async function main(argv, io) {
 		io.out(`hollware ${readVersion()}`);
 		return 0;
 	}
-	if (first === "export") {
-		io.err("hollware export: not implemented yet (planned for v0.2)");
-		return 1;
-	}
 	if (![
 		"init",
 		"migrate",
@@ -88,7 +84,8 @@ async function main(argv, io) {
 		"doctor",
 		"token",
 		"invite",
-		"import"
+		"import",
+		"export"
 	].includes(first)) {
 		io.err(`hollware: unknown command or flag "${printable(first)}"\n\n${USAGE}`);
 		return 1;
@@ -106,12 +103,13 @@ async function main(argv, io) {
 async function run(command, args, io) {
 	switch (command) {
 		case "init": return (await import("./init-CBZPzLBs.mjs")).init(args, io);
-		case "migrate": return (await import("./migrate-Ka2Mm06e.mjs")).migrate(args, io);
+		case "migrate": return (await import("./migrate-CRFTlOVG.mjs")).migrate(args, io);
 		case "deploy": return (await import("./deploy-4tusYOMV.mjs")).deploy(args, io);
 		case "doctor": return (await import("./doctor-DiKAktVd.mjs")).doctor(args, io);
-		case "token": return (await import("./token-BND4Rsxj.mjs")).token(args, io);
+		case "token": return (await import("./token-BasKoAEC.mjs")).token(args, io);
 		case "invite": return (await import("./invite-Ck-aqpN8.mjs")).invite(args, io);
-		default: return (await import("./import-DG8AABZQ.mjs")).importContent(args, io);
+		case "export": return (await import("./export-DprcsjU_.mjs")).exportContent(args, io);
+		default: return (await import("./import-JNLtBmyD.mjs")).importContent(args, io);
 	}
 }
 function isEntryPoint() {

package/dist/migrate-CRFTlOVG.mjs

@@ -0,0 +1 @@
+export { i as migrate } from "./migrate-BBfF-mkE.mjs";

package/dist/token-BasKoAEC.mjs

@@ -0,0 +1 @@
+export { c as token } from "./token-CLQpD4ed.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hollware",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "The Hollware CLI: init, migrate, token, import and export.",
   "homepage": "https://hollware.com",
   "bugs": {
@@ -31,17 +31,17 @@
     "provenance": true
   },
   "dependencies": {
-    "@hollware/core": "0.9.1",
+    "@hollware/core": "0.10.0",
     "@modelcontextprotocol/client": "2.3.1",
-    "zod": "4.6.5"
+    "zod": "4.6.7"
   },
   "devDependencies": {
     "@modelcontextprotocol/server": "2.3.1",
     "@types/node": "24.19.2",
     "publint": "0.3.25",
     "typescript": "7.0.2",
-    "vite-plus": "1.1.0",
-    "wrangler": "4.150.0"
+    "vite-plus": "1.2.0",
+    "wrangler": "4.151.0"
   },
   "engines": {
     "node": ">=24.11.0"

package/dist/migrate-Ka2Mm06e.mjs

@@ -1,2 +0,0 @@
-import { i as migrate } from "./migrate-BBfF-mkE.mjs";
-export { migrate };

package/dist/token-BND4Rsxj.mjs

@@ -1,2 +0,0 @@
-import { c as token } from "./token-CLQpD4ed.mjs";
-export { token };