@doxbrix/doxloop 0.1.4 → 0.2.0

package/dist/docs-site.js

@@ -0,0 +1,233 @@
+/**
+ * `docs-site` sources: an existing documentation website crawled into a
+ * read-only Markdown snapshot that the authoring agent reads as evidence of the
+ * documentation being rewritten.
+ *
+ * Snapshots live beside other materialized sources under
+ * `<parent>/.doxloop-sources/<projectId>/<name>/docs-<hash>/`, outside the
+ * documentation deployment boundary, so the crawled third-party content can
+ * never be published by accident. The layout is plain files: `snapshot.json`
+ * (page metadata, skipped URLs, broken links, warnings), `index.md` (a table of
+ * every page the agent can skim before opening files), and `pages/**.md` (one
+ * Markdown page per crawled URL with its title and original URL in frontmatter).
+ */
+import { createHash } from 'node:crypto';
+import { mkdir, mkdtemp, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { DoxloopError } from './errors.js';
+import { pathExists } from './fs.js';
+import { REDIRECTS_FILE, readRedirects } from './page-operations.js';
+import { portableSourcePath } from './remote-source.js';
+export const DOCS_SITE_SNAPSHOT_FILE = 'snapshot.json';
+export const DOCS_SITE_INDEX_FILE = 'index.md';
+export const DOCS_SITE_PAGES_DIRECTORY = 'pages';
+/** Write a crawl result as a snapshot directory outside the documentation project. */
+export async function materializeDocsSiteSnapshot(root, name, snapshot) {
+    const projectId = createHash('sha256').update(resolve(root)).digest('hex').slice(0, 12);
+    const destination = join(dirname(resolve(root)), '.doxloop-sources', projectId, safeSourceName(name), `docs-${snapshot.hash.slice(0, 12)}`);
+    const manifest = docsSiteManifest(snapshot);
+    if (!(await pathExists(destination))) {
+        const parent = dirname(destination);
+        await mkdir(parent, { recursive: true });
+        const temporary = await mkdtemp(join(parent, '.docs-'));
+        try {
+            await writeFile(join(temporary, DOCS_SITE_SNAPSHOT_FILE), `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+            await writeFile(join(temporary, DOCS_SITE_INDEX_FILE), docsSiteIndexMarkdown(manifest), 'utf8');
+            for (const page of snapshot.pages) {
+                const file = join(temporary, docsSitePageFile(page.path));
+                await mkdir(dirname(file), { recursive: true });
+                await writeFile(file, docsSitePageMarkdown(page), 'utf8');
+            }
+            await rename(temporary, destination);
+        }
+        catch (error) {
+            await rm(temporary, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    return { path: destination, manifest, site: docsSiteSource(manifest) };
+}
+/** The binding stored in project.json for a materialized snapshot. */
+export function docsSiteBinding(root, name, materialized, scope) {
+    return {
+        name,
+        path: portableSourcePath(root, materialized.path),
+        kind: 'docs-site',
+        site: materialized.site,
+        ...(scope ? { scope } : {}),
+    };
+}
+export function docsSiteSource(manifest) {
+    return {
+        url: manifest.url,
+        crawledAt: manifest.crawledAt,
+        pages: manifest.totals.pages,
+        words: manifest.totals.words,
+        hash: manifest.hash,
+        ...(manifest.generator ? { generator: manifest.generator } : {}),
+        ...(manifest.truncated ? { truncated: true } : {}),
+    };
+}
+export function docsSiteManifest(snapshot) {
+    return {
+        ...snapshot,
+        pages: snapshot.pages.map(({ markdown: _markdown, ...page }) => ({ ...page, file: docsSitePageFile(page.path) })),
+    };
+}
+/** Read the manifest of a materialized `docs-site` source. */
+export async function readDocsSiteManifest(root, source) {
+    const path = join(resolve(root, source.path), DOCS_SITE_SNAPSHOT_FILE);
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch {
+        throw new DoxloopError(`The documentation site snapshot for source "${source.name}" is missing: ${path}. Re-crawl the site from Sources.`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new DoxloopError(`The documentation site snapshot for source "${source.name}" is not valid JSON: ${path}`);
+    }
+    if (!isManifest(parsed))
+        throw new DoxloopError(`The documentation site snapshot for source "${source.name}" is invalid: ${path}`);
+    return parsed;
+}
+export async function assertDocsSiteSnapshot(root, source) {
+    await readDocsSiteManifest(root, source);
+}
+/**
+ * Snapshot-relative Markdown file for a crawled page path. The entry page is
+ * `pages/index.md`; nested URLs keep their folders so the agent can relate a
+ * file back to the original site structure.
+ */
+export function docsSitePageFile(pagePath) {
+    const segments = pagePath.split('/').map((segment) => segment.trim()).filter((segment) => segment && segment !== '.' && segment !== '..')
+        .map((segment) => segment.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^\.+/, '').replace(/\.(md|mdx|html?)$/i, '') || 'page');
+    if (segments.length === 0)
+        return `${DOCS_SITE_PAGES_DIRECTORY}/index.md`;
+    return `${DOCS_SITE_PAGES_DIRECTORY}/${segments.join('/')}.md`;
+}
+export function docsSitePageMarkdown(page) {
+    const frontmatter = [
+        `title: ${JSON.stringify(page.title)}`,
+        `url: ${JSON.stringify(page.url)}`,
+        ...(page.description ? [`description: ${JSON.stringify(page.description)}`] : []),
+        `crawledAt: ${JSON.stringify(page.fetchedAt)}`,
+        `words: ${page.words}`,
+    ];
+    return `---\n${frontmatter.join('\n')}\n---\n\n${page.markdown}\n`;
+}
+export function docsSiteIndexMarkdown(manifest) {
+    const lines = [
+        `# Existing documentation snapshot`,
+        '',
+        `- Site: ${manifest.url}`,
+        `- Crawled: ${manifest.crawledAt}`,
+        `- Pages: ${manifest.totals.pages} (${manifest.totals.words} words, ${manifest.totals.images} images)`,
+        ...(manifest.generator ? [`- Generator: ${manifest.generator}`] : []),
+        `- Discovered through: ${manifest.discovery.length > 0 ? manifest.discovery.join(', ') : 'entry page only'}`,
+        ...(manifest.truncated ? [`- Truncated: the crawl stopped at ${manifest.pageLimit} pages; ${manifest.totals.discovered - manifest.totals.pages} discovered pages were not fetched.`] : []),
+        '',
+        'This snapshot is read-only evidence of the documentation being rewritten. Each page file records its original URL in frontmatter. Verify factual claims against the configured product sources before reusing them.',
+        '',
+        '## Pages',
+        '',
+        '| File | Title | Words | Original URL |',
+        '| --- | --- | --- | --- |',
+        ...manifest.pages.map((page) => `| ${page.file} | ${cell(page.title)} | ${page.words} | ${page.url} |`),
+    ];
+    if (manifest.brokenLinks.length > 0) {
+        lines.push('', `## Broken internal links (${manifest.brokenLinks.length})`, '');
+        for (const link of manifest.brokenLinks.slice(0, 100))
+            lines.push(`- ${link.url} (linked from ${link.from})${link.status ? ` — HTTP ${link.status}` : ''}`);
+    }
+    if (manifest.skipped.length > 0) {
+        lines.push('', `## Skipped URLs (${manifest.skipped.length})`, '');
+        for (const item of manifest.skipped.slice(0, 100))
+            lines.push(`- ${item.url} — ${item.reason}`);
+    }
+    if (manifest.warnings.length > 0) {
+        lines.push('', '## Crawl warnings', '');
+        for (const warning of manifest.warnings)
+            lines.push(`- ${warning}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+/** Human-readable one-line description used by health, tables, and CLI output. */
+export function describeDocsSite(site) {
+    const date = new Date(site.crawledAt);
+    const when = Number.isNaN(date.getTime()) ? site.crawledAt : date.toISOString().slice(0, 10);
+    return `${site.pages} page${site.pages === 1 ? '' : 's'} · crawled ${when}${site.generator ? ` · ${site.generator}` : ''}`;
+}
+/**
+ * Redirects implied by an approved plan: every existing page that a new page
+ * absorbs, when the old route differs from the new one. Written to the same
+ * redirect file page moves use, so the preview and the Doxbrix build honor
+ * them, and exported for the old host when the new site is deployed elsewhere.
+ * The site root is never redirected: the new site always serves its own
+ * navigation homepage there, and a root redirect would only send readers to a
+ * planned path the authored pages may not use.
+ */
+export function existingDocumentationRedirects(plan) {
+    const redirects = {};
+    const pagesById = new Map(plan.pages.map((page) => [page.id, page]));
+    const routeOf = (path) => `/${path.replace(/^\/+/, '').replace(/\.(mdx?|rst|html?)$/i, '').replace(/(^|\/)index$/, '')}`.replace(/\/+$/, '') || '/';
+    const newRoutes = new Set(plan.pages.filter((page) => page.action !== 'remove').map((page) => routeOf(page.path)));
+    for (const assessment of plan.existingDocumentation ?? []) {
+        for (const disposition of assessment.pages) {
+            if (disposition.disposition === 'drop')
+                continue;
+            const target = disposition.into.map((id) => pagesById.get(id)).find((page) => page !== undefined && page.action !== 'remove');
+            if (!target)
+                continue;
+            const from = existingPageRoute(disposition);
+            const to = routeOf(target.path);
+            if (!from || from === '/' || from === to || newRoutes.has(from) || !/^\/[a-zA-Z0-9/_-]*$/.test(from) || !/^\/[a-zA-Z0-9/_-]*$/.test(to))
+                continue;
+            redirects[from] = to;
+        }
+    }
+    return redirects;
+}
+export async function writeExistingDocumentationRedirects(root, plan) {
+    const additions = existingDocumentationRedirects(plan);
+    if (Object.keys(additions).length === 0)
+        return {};
+    const current = await readRedirects(root);
+    const merged = { ...current };
+    for (const [from, to] of Object.entries(additions))
+        if (!(from in merged))
+            merged[from] = to;
+    await mkdir(join(root, '.doxloop'), { recursive: true });
+    await writeFile(join(root, REDIRECTS_FILE), `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+    return additions;
+}
+function existingPageRoute(disposition) {
+    if (disposition.url) {
+        try {
+            const pathname = new URL(disposition.url).pathname.replace(/\/index\.html?$/i, '/').replace(/\.html?$/i, '').replace(/\/+$/, '');
+            return pathname === '' ? '/' : pathname;
+        }
+        catch { /* fall back to the snapshot path */ }
+    }
+    const relative = disposition.path.replace(/^pages\//, '').replace(/\.md$/, '').replace(/(^|\/)index$/, '');
+    return `/${relative}`.replace(/\/+$/, '') || '/';
+}
+function safeSourceName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^\.+/, '') || 'docs';
+}
+function cell(value) {
+    return value.replace(/\|/g, '\\|').replace(/\s+/g, ' ').trim();
+}
+function isManifest(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const manifest = value;
+    return manifest.schemaVersion === 1 && typeof manifest.url === 'string' && typeof manifest.crawledAt === 'string' && typeof manifest.hash === 'string' &&
+        Array.isArray(manifest.pages) && manifest.pages.every((page) => page && typeof page === 'object' && typeof page.file === 'string' && typeof page.url === 'string') &&
+        Boolean(manifest.totals) && typeof manifest.totals.pages === 'number' && Array.isArray(manifest.skipped) && Array.isArray(manifest.brokenLinks) && Array.isArray(manifest.warnings) && Array.isArray(manifest.discovery);
+}
+//# sourceMappingURL=docs-site.js.map

package/dist/doctor.js

@@ -1,6 +1,7 @@
 import { createServer } from 'node:net';
 import { agentAuthenticationStatus, chooseAgent, skillStatus, } from './agents.js';
 import { DoxloopError } from './errors.js';
+import { historyAvailable, historyRuntimeStatus } from './db.js';
 import { diagnoseGenerator } from './generator-manager.js';
 import { findProjectRoot, loadProject, resolveSeparateProjectLayout, validateProjectSourceBoundaries, } from './project.js';
 import { validateProject } from './validation.js';
@@ -46,6 +47,13 @@ export async function runDoctor(options) {
         await inspectExistingProject(options.cwd, checks);
     }
     await inspectAgent(options.agent, checks, preflight ? undefined : options.cwd);
+    const runtime = historyRuntimeStatus(process.versions.node);
+    const historyDisabled = process.env.DOXLOOP_NO_HISTORY === '1';
+    checks.push({
+        status: historyDisabled ? 'warning' : runtime.available && await historyAvailable() ? 'pass' : 'fail',
+        label: runtime.available ? 'Request history runtime is available' : 'Request history runtime',
+        detail: historyDisabled ? 'History is explicitly disabled by DOXLOOP_NO_HISTORY=1; requests and deployments will not appear in the UI history.' : runtime.detail,
+    });
     checks.push(await previewPortCheck());
     return {
         ready: checks.every((check) => check.status !== 'fail'),

package/dist/documentation-collections.d.ts

@@ -0,0 +1,23 @@
+import type { DoxloopProject } from './types.js';
+export interface DocumentationCollection {
+    directory: string;
+    version: string;
+    locale: string;
+    native: boolean;
+}
+export declare function documentationCollections(root: string, project: Pick<DoxloopProject, 'generator' | 'contentDir'>): Promise<DocumentationCollection[]>;
+export declare function collectionForPath(collections: DocumentationCollection[], path: string): DocumentationCollection | undefined;
+/** Snapshot an existing version/locale; translation remains a reviewed editing task. */
+export declare function createDocumentationCollection(root: string, input: {
+    sourceDirectory: string;
+    version: string;
+    locale: string;
+}): Promise<{
+    directory: string;
+    pages: string[];
+    message: string;
+    validation: import("./types.js").ValidationResult;
+    requestId?: string;
+    editId: string;
+}>;
+//# sourceMappingURL=documentation-collections.d.ts.map

package/dist/documentation-collections.js

@@ -0,0 +1,191 @@
+import { rewriteLinks } from './page-operations.js';
+import { readFile, readdir, mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import matter from 'gray-matter';
+import { applyDirectEdit, safePath } from './direct-edit.js';
+import { DoxloopError } from './errors.js';
+import { listFiles, pathExists } from './fs.js';
+import { readEvidenceMap, EVIDENCE_MAP_FILE } from './evidence.js';
+import { loadProject, loadSiteConfig, siteConfigPath, pageId } from './project.js';
+import { withProjectLock } from './project-lock.js';
+import { parseDocument } from 'yaml';
+const REGISTRY = '.doxloop/collections.json';
+export async function documentationCollections(root, project) {
+    const collections = [{ directory: project.contentDir, version: 'current', locale: 'default', native: true }];
+    if (project.generator === 'docusaurus') {
+        for (const name of await directories(root, 'versioned_docs'))
+            if (/^version-[\w.-]+$/.test(name))
+                collections.push({ directory: `versioned_docs/${name}`, version: name.slice(8), locale: 'default', native: true });
+        for (const locale of await directories(root, 'i18n'))
+            if (/^[\w-]+$/.test(locale)) {
+                const base = `i18n/${locale}/docusaurus-plugin-content-docs`;
+                for (const version of await directories(root, base))
+                    if (version === 'current' || /^version-[\w.-]+$/.test(version))
+                        collections.push({ directory: `${base}/${version}`, version: version === 'current' ? version : version.slice(8), locale, native: true });
+            }
+    }
+    try {
+        const recorded = JSON.parse(await readFile(await safePath(root, REGISTRY), 'utf8'));
+        for (const item of recorded) {
+            await safePath(root, item.directory);
+            if (!collections.some((collection) => collection.directory === item.directory))
+                collections.push(item);
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    return collections;
+}
+async function directories(root, path) {
+    try {
+        return (await readdir(await safePath(root, path), { withFileTypes: true })).filter((item) => item.isDirectory() && !item.isSymbolicLink()).map((item) => item.name);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        return [];
+    }
+}
+export function collectionForPath(collections, path) {
+    return [...collections].sort((a, b) => b.directory.length - a.directory.length).find((item) => !item.directory || path.startsWith(`${item.directory}/`));
+}
+/** Snapshot an existing version/locale; translation remains a reviewed editing task. */
+export async function createDocumentationCollection(root, input) {
+    return withProjectLock(root, 'write', async () => {
+        const project = await loadProject(root);
+        if (!['doxbrix', 'mkdocs', 'docusaurus'].includes(project.generator))
+            throw new DoxloopError('Version and locale collections currently support Doxbrix, MkDocs, and Docusaurus.');
+        for (const [label, value] of Object.entries({ version: input.version, locale: input.locale }))
+            if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/.test(value) || ['.', '..'].includes(value))
+                throw new DoxloopError(`Use a simple ${label} name with letters, numbers, dots, or hyphens.`);
+        const collections = await documentationCollections(root, project);
+        const source = collections.find((item) => item.directory === input.sourceDirectory);
+        if (!source)
+            throw new DoxloopError('Choose an existing source collection.');
+        const native = project.generator === 'docusaurus';
+        const destination = native ? input.locale === 'default' ? `versioned_docs/version-${input.version}` : `i18n/${input.locale}/docusaurus-plugin-content-docs/${input.version === 'current' ? 'current' : `version-${input.version}`}` : [project.contentDir, 'editions', input.version, input.locale].filter(Boolean).join('/');
+        if (collections.some((item) => item.version === input.version && item.locale === input.locale) || (await pathExists(await safePath(root, destination)) && await hasFiles(await safePath(root, destination))))
+            throw new DoxloopError('That version and locale already exists.');
+        const changes = new Map();
+        const sourceRoot = resolve(root, source.directory);
+        const files = await listFiles(sourceRoot, new Set(['.md', '.mdx', '.png', '.jpg', '.jpeg', '.svg', '.gif', '.webp', '.avif', '.pdf', '.json']), { ignoredDirectories: new Set(['.doxloop', 'node_modules', '.git', 'build', 'site', 'dist', 'editions']) });
+        const pages = [];
+        for (const absolute of files) {
+            const from = relative(root, absolute).replace(/\\/g, '/');
+            if (collectionForPath(collections, from)?.directory !== source.directory)
+                continue;
+            const local = relative(sourceRoot, absolute).replace(/\\/g, '/');
+            if (local.split('/').some((part) => part.startsWith('.') || ['node_modules', 'build', 'site', 'dist', 'editions'].includes(part)))
+                continue;
+            if (!/\.(mdx?|png|jpe?g|svg|gif|webp|avif|pdf|json)$/i.test(local))
+                continue;
+            const to = `${destination}/${local}`;
+            const data = await readFile(await safePath(root, from));
+            changes.set(to, data);
+            if (/\.mdx?$/.test(local)) {
+                const rewritten = rewriteLinks(data.toString(), (href) => {
+                    if (/^(?:[a-z][a-z0-9+.-]*:|#|\/)/i.test(href))
+                        return href;
+                    const [target, suffix = ''] = href.split(/(?=[?#])/s, 2);
+                    const resolved = resolve(dirname(join(root, from)), target);
+                    if (resolved.startsWith(`${sourceRoot}/`))
+                        return href;
+                    return relative(dirname(join(root, to)), resolved).replace(/\\/g, '/') + suffix;
+                });
+                changes.set(to, rewritten);
+                const parsed = matter(rewritten);
+                if (!native) {
+                    // The collection's directory defines the route; copied custom slugs must not collide.
+                    delete parsed.data.slug;
+                    parsed.data.locale = input.locale;
+                    parsed.data.version = input.version;
+                    changes.set(to, matter.stringify(parsed.content, parsed.data));
+                }
+                pages.push({ from, to, title: String(parsed.data.title ?? local) });
+            }
+        }
+        if (!pages.length)
+            throw new DoxloopError('The selected collection contains no Markdown pages.');
+        if (native) {
+            if (input.locale === 'default') {
+                if (input.version === 'current')
+                    throw new DoxloopError('The current version already exists.');
+                const versions = await jsonOr(root, 'versions.json', []);
+                let sidebarName = 'docs';
+                for (const sidebarPath of ['sidebars.js', 'sidebars.ts', 'sidebars.json']) {
+                    if (!(await pathExists(join(root, sidebarPath))))
+                        continue;
+                    const sidebar = await readFile(await safePath(root, sidebarPath), 'utf8');
+                    if (!/autogenerated/.test(sidebar))
+                        throw new DoxloopError('Custom Docusaurus sidebars require a reviewed native versioning proposal. No files were written.');
+                    sidebarName = /["']?([a-zA-Z][\w-]*)["']?\s*:\s*\[/.exec(sidebar)?.[1] ?? 'docs';
+                }
+                changes.set('versions.json', JSON.stringify([input.version, ...versions], null, 2) + '\n');
+                // Autogenerated sidebars work without executing arbitrary project configuration.
+                changes.set(`versioned_sidebars/version-${input.version}-sidebars.json`, JSON.stringify({ [sidebarName]: [{ type: 'autogenerated', dirName: '.' }] }, null, 2) + '\n');
+            }
+            else {
+                const configPath = (await Promise.all(['docusaurus.config.js', 'docusaurus.config.ts', 'docusaurus.config.mjs', 'docusaurus.config.cjs'].map(async (path) => await pathExists(join(root, path)) ? path : undefined))).find(Boolean);
+                if (!configPath)
+                    throw new DoxloopError('Docusaurus configuration was not found.');
+                const text = await readFile(await safePath(root, configPath), 'utf8');
+                const locales = /\blocales\s*:\s*\[([^\]]*)\]/.exec(text);
+                if (!locales || !/^[\s,'"\w-]*$/.test(locales[1]))
+                    throw new DoxloopError('Declare a literal i18n.locales array in Docusaurus configuration before creating a locale.');
+                if (!new RegExp(`['"]${input.locale}['"]`).test(locales[1]))
+                    changes.set(configPath, text.replace(locales[0], `locales: [${locales[1].trim().replace(/,$/, '')}, '${input.locale}']`));
+                if (input.version !== 'current' && !(await jsonOr(root, 'versions.json', [])).includes(input.version))
+                    throw new DoxloopError('Create the source version before translating it.');
+            }
+        }
+        else if (project.generator === 'doxbrix') {
+            const site = await loadSiteConfig(root, project);
+            const nav = pages.map((page) => ({ type: 'page', file: pageId(join(root, project.contentDir), join(root, page.to)), label: page.title }));
+            site.spaces.push({ name: `${input.version} · ${input.locale}`, nav });
+            changes.set(relative(root, await siteConfigPath(root, project)), JSON.stringify(site, null, 2) + '\n');
+        }
+        else {
+            const configPath = await pathExists(join(root, 'mkdocs.yml')) ? 'mkdocs.yml' : 'mkdocs.yaml';
+            const document = parseDocument(await readFile(await safePath(root, configPath), 'utf8'));
+            const nav = document.toJS().nav;
+            if (!Array.isArray(nav))
+                throw new DoxloopError('Define an explicit MkDocs nav list before creating a collection.');
+            document.set('nav', [...nav, { [`${input.version} · ${input.locale}`]: pages.map((page) => ({ [page.title]: relative(join(root, project.contentDir), join(root, page.to)).replace(/\\/g, '/') })) }]);
+            changes.set(configPath, document.toString());
+        }
+        const map = await readEvidenceMap(root) ?? { schemaVersion: 1, pages: {} };
+        for (const page of pages)
+            map.pages[page.to] = { sources: map.pages[page.from]?.sources ?? [], confidence: 'needs-human' };
+        changes.set(EVIDENCE_MAP_FILE, JSON.stringify(map, null, 2) + '\n');
+        const recorded = await jsonOr(root, REGISTRY, []);
+        changes.set(REGISTRY, JSON.stringify([...recorded, { directory: destination, version: input.version, locale: input.locale, native }], null, 2) + '\n');
+        const result = await applyDirectEdit(root, { kind: 'metadata', requestText: `Created ${input.version} / ${input.locale} from ${source.version} / ${source.locale}; copied text requires review`, files: [...changes.keys()], pagesChanged: pages.length, apply: async () => {
+                for (const [file, text] of changes) {
+                    const absolute = await safePath(root, file);
+                    await mkdir(dirname(absolute), { recursive: true });
+                    await writeFile(absolute, text);
+                }
+            } });
+        return { ...result, directory: destination, pages: pages.map((page) => page.to), message: 'Collection created. Review or translate its copied text before publication; verification was not inherited.' };
+    });
+}
+async function jsonOr(root, path, fallback) {
+    try {
+        return JSON.parse(await readFile(await safePath(root, path), 'utf8'));
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        return fallback;
+    }
+}
+async function hasFiles(directory) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        if (!entry.isDirectory() || entry.isSymbolicLink() || await hasFiles(join(directory, entry.name)))
+            return true;
+    }
+    return false;
+}
+//# sourceMappingURL=documentation-collections.js.map