@nuucognition/flint-cli 0.1.0-beta.0

package/dist/chunk-BVYUS7NX.js

@@ -0,0 +1,386 @@
+// ../../packages/flint/src/exports.ts
+import { readdir, readFile, mkdir, writeFile, rm, stat } from "fs/promises";
+import { join, basename, dirname, resolve, relative, sep } from "path";
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isPathWithinRoot(root, target) {
+  const resolvedRoot = resolve(root);
+  const resolvedTarget = resolve(target);
+  if (resolvedTarget === resolvedRoot) {
+    return true;
+  }
+  return resolvedTarget.startsWith(resolvedRoot + sep);
+}
+function stripFrontmatter(content) {
+  return content.replace(/^---\n[\s\S]*?\n---\n*/, "");
+}
+function getContentWithoutFrontmatter(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n*/);
+  if (match) {
+    return content.slice(match[0].length);
+  }
+  return content;
+}
+async function collectReferencedFiles(content, flintPath, collected = /* @__PURE__ */ new Set(), visited = /* @__PURE__ */ new Set(), depth = -1, currentDepth = 0) {
+  if (depth !== -1 && currentDepth >= depth) {
+    return collected;
+  }
+  const contentWithoutFrontmatter = getContentWithoutFrontmatter(content);
+  const linkRegex = /!?\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]*)?\]\]/g;
+  let match;
+  while ((match = linkRegex.exec(contentWithoutFrontmatter)) !== null) {
+    const captured = match[1];
+    if (!captured) continue;
+    const target = captured.trim();
+    const sourcePath = await resolveDocument(target, flintPath);
+    if (!sourcePath || visited.has(sourcePath)) {
+      continue;
+    }
+    collected.add(sourcePath);
+    visited.add(sourcePath);
+    if (depth === -1 || currentDepth + 1 < depth) {
+      const referencedContent = await readFile(sourcePath, "utf-8");
+      await collectReferencedFiles(referencedContent, flintPath, collected, visited, depth, currentDepth + 1);
+    }
+  }
+  return collected;
+}
+async function expandEmbeds(content, flintPath, visited = /* @__PURE__ */ new Set()) {
+  const embedRegex = /!\[\[([^\]|#]+)(?:#[^\]|]*)?(?:\|[^\]]*)?\]\]/g;
+  let result = content;
+  let match;
+  const matches = [];
+  while ((match = embedRegex.exec(content)) !== null) {
+    const captured = match[1];
+    if (!captured) continue;
+    matches.push({ full: match[0], target: captured.trim() });
+  }
+  for (const { full, target } of matches) {
+    const sourcePath = await resolveDocument(target, flintPath);
+    if (!sourcePath) {
+      continue;
+    }
+    if (visited.has(sourcePath)) {
+      result = result.replace(full, `<!-- Circular embed removed: ${target} -->`);
+      continue;
+    }
+    let embeddedContent = await readFile(sourcePath, "utf-8");
+    embeddedContent = embeddedContent.replace(/^---\n[\s\S]*?\n---\n*/, "");
+    const newVisited = new Set(visited);
+    newVisited.add(sourcePath);
+    embeddedContent = await expandEmbeds(embeddedContent, flintPath, newVisited);
+    const fileName = basename(sourcePath, ".md");
+    const quotedContent = embeddedContent.trim().split("\n").map((line) => `> ${line}`).join("\n");
+    const formattedEmbed = `> **${fileName}**
+>
+${quotedContent}`;
+    result = result.replace(full, formattedEmbed);
+  }
+  return result;
+}
+async function rewriteWikilinks(content, flintName, flintPath, exportNameBySourcePath, resolveCache) {
+  const wikilinkRegex = /\[\[([^\]|#]+)(#[^\]|]*)?((\|)([^\]]*))?\]\]/g;
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  while ((match = wikilinkRegex.exec(content)) !== null) {
+    const matchIndex = match.index ?? 0;
+    result += content.slice(lastIndex, matchIndex);
+    const target = match[1]?.trim();
+    const section = match[2] || "";
+    const alias = match[5];
+    if (!target) {
+      result += match[0];
+      lastIndex = matchIndex + match[0].length;
+      continue;
+    }
+    const resolvedPath = await resolveDocumentCached(target, flintPath, resolveCache);
+    const exportBaseName = resolvedPath ? exportNameBySourcePath.get(resolvedPath) : void 0;
+    if (exportBaseName) {
+      const prefixedName = `Export - (${flintName}) ${exportBaseName}`;
+      const displayAlias = alias || target;
+      result += `[[${prefixedName}${section}|${displayAlias}]]`;
+    } else {
+      result += match[0];
+    }
+    lastIndex = matchIndex + match[0].length;
+  }
+  result += content.slice(lastIndex);
+  return result;
+}
+function parseExportDocument(content, name, sourcePath) {
+  const files = [];
+  let description;
+  let depth = 1;
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (frontmatterMatch && frontmatterMatch[1]) {
+    const descMatch = frontmatterMatch[1].match(/description:\s*(.+)/);
+    if (descMatch && descMatch[1]) {
+      description = descMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+    const depthMatch = frontmatterMatch[1].match(/export-depth:\s*(-?\d+)/);
+    if (depthMatch && depthMatch[1]) {
+      depth = parseInt(depthMatch[1], 10);
+    }
+  }
+  const contentWithoutFrontmatter = getContentWithoutFrontmatter(content);
+  const wikilinkRegex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+  let match;
+  while ((match = wikilinkRegex.exec(contentWithoutFrontmatter)) !== null) {
+    if (match[1]) files.push(match[1]);
+  }
+  const mdLinkRegex = /\[([^\]]+)\]\(([^)]+\.md)\)/g;
+  while ((match = mdLinkRegex.exec(contentWithoutFrontmatter)) !== null) {
+    if (match[2]) files.push(match[2]);
+  }
+  return { name, description, depth, files, sourcePath };
+}
+async function findFilesRecursively(dir, fileName, matches = []) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isFile() && entry.name === fileName) {
+        matches.push(fullPath);
+      }
+      if (entry.isDirectory()) {
+        await findFilesRecursively(fullPath, fileName, matches);
+      }
+    }
+  } catch {
+  }
+  return matches;
+}
+async function findExportFiles(dir, files = []) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isFile() && entry.name.startsWith("(Export) ") && entry.name.endsWith(".md")) {
+        files.push(fullPath);
+      }
+      if (entry.isDirectory()) {
+        await findExportFiles(fullPath, files);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+async function resolveDocument(docRef, flintPath) {
+  const trimmedRef = docRef.trim();
+  if (!trimmedRef) {
+    return null;
+  }
+  const normalizedRef = trimmedRef.replace(/\\/g, "/");
+  const hasPath = normalizedRef.includes("/");
+  if (hasPath) {
+    const cleanedRef = normalizedRef.replace(/^\.?\//, "");
+    const withExt = cleanedRef.endsWith(".md") ? cleanedRef : `${cleanedRef}.md`;
+    const directCandidate = resolve(flintPath, withExt);
+    if (isPathWithinRoot(flintPath, directCandidate) && await exists(directCandidate)) {
+      return directCandidate;
+    }
+    if (!cleanedRef.startsWith("Mesh/")) {
+      const meshCandidate = resolve(flintPath, "Mesh", withExt);
+      if (isPathWithinRoot(flintPath, meshCandidate) && await exists(meshCandidate)) {
+        return meshCandidate;
+      }
+    }
+  }
+  const docName = basename(trimmedRef);
+  const fileName = docName.endsWith(".md") ? docName : `${docName}.md`;
+  const meshDir = join(flintPath, "Mesh");
+  const matches = await findFilesRecursively(meshDir, fileName);
+  if (matches.length === 0) {
+    return null;
+  }
+  matches.sort();
+  return matches[0] ?? null;
+}
+async function resolveDocumentCached(docRef, flintPath, cache) {
+  const key = docRef.trim();
+  if (cache.has(key)) {
+    return cache.get(key) ?? null;
+  }
+  const resolved = await resolveDocument(key, flintPath);
+  cache.set(key, resolved);
+  return resolved;
+}
+function getDisambiguatedExportName(flintPath, sourcePath, baseName) {
+  const relativePath = relative(flintPath, sourcePath);
+  const relativeDir = dirname(relativePath);
+  if (!relativeDir || relativeDir === ".") {
+    return baseName;
+  }
+  const dirLabel = relativeDir.split(sep).join(" - ");
+  return `${baseName} (${dirLabel})`;
+}
+async function scanExports(flintPath) {
+  const meshDir = join(flintPath, "Mesh");
+  if (!await exists(meshDir)) {
+    return [];
+  }
+  const exportFiles = await findExportFiles(meshDir);
+  const manifests = [];
+  for (const filePath of exportFiles) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const fileName = basename(filePath, ".md");
+      const name = fileName.replace(/^\(Export\)\s*/, "");
+      const manifest = parseExportDocument(content, name, filePath);
+      manifests.push(manifest);
+    } catch {
+    }
+  }
+  return manifests;
+}
+async function buildExport(manifest, flintPath) {
+  const exportsDir = join(flintPath, "Exports");
+  const outputDir = join(exportsDir, manifest.name);
+  if (await exists(outputDir)) {
+    await rm(outputDir, { recursive: true });
+  }
+  await mkdir(outputDir, { recursive: true });
+  const folderName = basename(flintPath);
+  const flintName = folderName.replace(/^\(Mesh\)\s*/, "").replace(/^\(Flint\)\s*/, "");
+  const resolvedFiles = [];
+  const processedPaths = /* @__PURE__ */ new Set();
+  processedPaths.add(manifest.sourcePath);
+  for (const docRef of manifest.files) {
+    const sourcePath = await resolveDocument(docRef, flintPath);
+    if (!sourcePath || processedPaths.has(sourcePath)) continue;
+    resolvedFiles.push({ sourcePath, docRef });
+    processedPaths.add(sourcePath);
+  }
+  const depth = manifest.depth;
+  const allReferencedFiles = /* @__PURE__ */ new Set();
+  const exportContent = await readFile(manifest.sourcePath, "utf-8");
+  await collectReferencedFiles(exportContent, flintPath, allReferencedFiles, new Set(processedPaths), depth, 0);
+  for (const { sourcePath } of resolvedFiles) {
+    const content = await readFile(sourcePath, "utf-8");
+    await collectReferencedFiles(content, flintPath, allReferencedFiles, new Set(processedPaths), depth, 1);
+  }
+  for (const refPath of allReferencedFiles) {
+    if (!processedPaths.has(refPath)) {
+      resolvedFiles.push({ sourcePath: refPath, docRef: basename(refPath, ".md") });
+      processedPaths.add(refPath);
+    }
+  }
+  const allExportFiles = [
+    { sourcePath: manifest.sourcePath, baseName: manifest.name },
+    ...resolvedFiles.map((f) => ({ sourcePath: f.sourcePath, baseName: basename(f.sourcePath, ".md") }))
+  ];
+  const baseNameCounts = /* @__PURE__ */ new Map();
+  for (const { baseName } of allExportFiles) {
+    baseNameCounts.set(baseName, (baseNameCounts.get(baseName) || 0) + 1);
+  }
+  const duplicateBaseNames = new Set(
+    Array.from(baseNameCounts.entries()).filter(([, count]) => count > 1).map(([name]) => name)
+  );
+  const exportNameBySourcePath = /* @__PURE__ */ new Map();
+  for (const { sourcePath, baseName } of allExportFiles) {
+    const exportName = duplicateBaseNames.has(baseName) ? getDisambiguatedExportName(flintPath, sourcePath, baseName) : baseName;
+    exportNameBySourcePath.set(sourcePath, exportName);
+  }
+  let filesCopied = 0;
+  const copiedFiles = [];
+  const resolveCache = /* @__PURE__ */ new Map();
+  let rootContent = await readFile(manifest.sourcePath, "utf-8");
+  rootContent = stripFrontmatter(rootContent);
+  rootContent = await expandEmbeds(rootContent, flintPath, /* @__PURE__ */ new Set([manifest.sourcePath]));
+  rootContent = await rewriteWikilinks(rootContent, flintName, flintPath, exportNameBySourcePath, resolveCache);
+  const rootExportName = exportNameBySourcePath.get(manifest.sourcePath) || manifest.name;
+  const rootFileName = `Export - (${flintName}) ${rootExportName}.md`;
+  await writeFile(join(outputDir, rootFileName), rootContent);
+  copiedFiles.push(rootFileName);
+  filesCopied++;
+  for (const { sourcePath } of resolvedFiles) {
+    const exportBaseName = exportNameBySourcePath.get(sourcePath) || basename(sourcePath, ".md");
+    const prefixedName = `Export - (${flintName}) ${exportBaseName}.md`;
+    const destPath = join(outputDir, prefixedName);
+    let content = await readFile(sourcePath, "utf-8");
+    content = stripFrontmatter(content);
+    content = await expandEmbeds(content, flintPath, /* @__PURE__ */ new Set([sourcePath]));
+    content = await rewriteWikilinks(content, flintName, flintPath, exportNameBySourcePath, resolveCache);
+    await writeFile(destPath, content);
+    copiedFiles.push(prefixedName);
+    filesCopied++;
+  }
+  const manifestJson = {
+    name: manifest.name,
+    flint: flintName,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: copiedFiles
+  };
+  await writeFile(
+    join(outputDir, "_manifest.json"),
+    JSON.stringify(manifestJson, null, 2)
+  );
+  return {
+    name: manifest.name,
+    outputPath: outputDir,
+    filesCopied
+  };
+}
+async function buildExportByName(flintPath, exportName) {
+  const manifests = await scanExports(flintPath);
+  const manifest = manifests.find((m) => m.name === exportName);
+  if (!manifest) {
+    return null;
+  }
+  return buildExport(manifest, flintPath);
+}
+async function cleanupStaleExports(flintPath) {
+  const exportsDir = join(flintPath, "Exports");
+  const removed = [];
+  if (!await exists(exportsDir)) {
+    return removed;
+  }
+  const manifests = await scanExports(flintPath);
+  const validExportNames = new Set(manifests.map((m) => m.name));
+  const entries = await readdir(exportsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (!validExportNames.has(entry.name)) {
+        try {
+          await rm(join(exportsDir, entry.name), { recursive: true });
+          removed.push(entry.name);
+        } catch {
+        }
+      }
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      try {
+        await rm(join(exportsDir, entry.name));
+        removed.push(`${entry.name} (legacy manifest)`);
+      } catch {
+      }
+    }
+  }
+  return removed;
+}
+async function buildAllExports(flintPath) {
+  const removed = await cleanupStaleExports(flintPath);
+  const manifests = await scanExports(flintPath);
+  const results = [];
+  for (const manifest of manifests) {
+    const result = await buildExport(manifest, flintPath);
+    results.push(result);
+  }
+  return { results, removed };
+}
+
+export {
+  scanExports,
+  buildExport,
+  buildExportByName,
+  cleanupStaleExports,
+  buildAllExports
+};