@treeseed/sdk 0.4.8 → 0.4.10

package/dist/platform/published-content-pipeline.js

@@ -0,0 +1,543 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, extname, join, relative, resolve } from "node:path";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import { toString } from "mdast-util-to-string";
+import { parseFrontmatterDocument } from "../frontmatter.js";
+import { buildTenantBookRuntime } from "./books-data.js";
+import { exportBookLibrary, exportBookPackage } from "./book-export.js";
+import {
+  PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
+  resolvePublishedContentPreviewTtlHours,
+  resolveTeamScopedContentLocator
+} from "./published-content.js";
+function stableHash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function inferContentType(fileName) {
+  const extension = extname(fileName).toLowerCase();
+  if (extension === ".json") return "application/json";
+  if (extension === ".md") return "text/markdown; charset=utf-8";
+  if (extension === ".mdx") return "text/mdx; charset=utf-8";
+  return "application/octet-stream";
+}
+function objectPointerForBuffer(teamId, buffer, kind, extension = ".json") {
+  const sha256 = stableHash(buffer);
+  return {
+    objectKey: `teams/${teamId}/${kind}/${sha256}${extension}`,
+    sha256,
+    size: buffer.byteLength,
+    contentType: inferContentType(`entry${extension}`)
+  };
+}
+function objectInputForJson(teamId, kind, value) {
+  const buffer = Buffer.from(JSON.stringify(value, null, 2));
+  const pointer = objectPointerForBuffer(teamId, buffer, kind, ".json");
+  return {
+    pointer,
+    object: {
+      pointer: { ...pointer, contentType: "application/json" },
+      body: buffer,
+      httpMetadata: { contentType: "application/json" }
+    }
+  };
+}
+function objectInputForFile(teamId, filePath, kind) {
+  const buffer = readFileSync(filePath);
+  const extension = extname(filePath) || ".bin";
+  const pointer = objectPointerForBuffer(teamId, buffer, kind, extension);
+  return {
+    pointer: { ...pointer, contentType: inferContentType(filePath) },
+    object: {
+      pointer: { ...pointer, contentType: inferContentType(filePath) },
+      body: buffer,
+      httpMetadata: { contentType: inferContentType(filePath) }
+    }
+  };
+}
+function normalizeRelativeMarkdownPath(filePath, rootPath) {
+  return relative(rootPath, filePath).replaceAll("\\", "/");
+}
+function normalizeSlug(model, relativePath, frontmatter) {
+  const configured = typeof frontmatter.slug === "string" && frontmatter.slug.trim() ? frontmatter.slug.trim() : relativePath.replace(/\.(md|mdx)$/iu, "").replace(/\/index$/iu, "").replace(/^\/+|\/+$/gu, "");
+  if (model === "docs") {
+    if (configured === "knowledge" || configured.startsWith("knowledge/")) {
+      return configured;
+    }
+    return configured ? `knowledge/${configured}` : "knowledge";
+  }
+  return configured || basename(relativePath, extname(relativePath));
+}
+function inferTitle(relativePath, frontmatter) {
+  if (typeof frontmatter.title === "string" && frontmatter.title.trim()) {
+    return frontmatter.title.trim();
+  }
+  if (typeof frontmatter.name === "string" && frontmatter.name.trim()) {
+    return frontmatter.name.trim();
+  }
+  return basename(relativePath, extname(relativePath)).replace(/[-_]+/g, " ").replace(/\b\w/g, (character) => character.toUpperCase());
+}
+function inferSummary(frontmatter, searchText) {
+  for (const field of ["summary", "description", "excerpt"]) {
+    if (typeof frontmatter[field] === "string" && frontmatter[field].trim()) {
+      return frontmatter[field].trim();
+    }
+  }
+  return searchText.trim().slice(0, 240) || void 0;
+}
+function inferStatus(frontmatter) {
+  if (typeof frontmatter.status === "string" && frontmatter.status.trim()) {
+    return frontmatter.status.trim();
+  }
+  if (frontmatter.draft === true) {
+    return "draft";
+  }
+  return "live";
+}
+function inferVisibility(frontmatter) {
+  if (typeof frontmatter.visibility === "string" && frontmatter.visibility.trim()) {
+    return frontmatter.visibility.trim();
+  }
+  if (frontmatter.draft === true) {
+    return "team";
+  }
+  return "public";
+}
+function markdownText(body) {
+  try {
+    const tree = unified().use(remarkParse).parse(body);
+    return toString(tree).replace(/\s+/g, " ").trim();
+  } catch {
+    return body.replace(/`{1,3}[^`]*`{1,3}/g, " ").replace(/[#>*_~[\]()!-]+/g, " ").replace(/\s+/g, " ").trim();
+  }
+}
+function canonicalEntryPath(entry) {
+  return `${entry.model}/${entry.slug || entry.id}`.replace(/^\/+|\/+$/g, "");
+}
+function canonicalArtifactKey(artifact) {
+  return `${artifact.kind}:${artifact.itemId}:${artifact.version}`;
+}
+function entrySignature(entry) {
+  const { publishedAt, ...rest } = entry;
+  return stableHash(JSON.stringify(rest));
+}
+function artifactSignature(artifact) {
+  const { publishedAt, ...rest } = artifact;
+  return stableHash(JSON.stringify(rest));
+}
+function listMarkdownFiles(rootPath) {
+  if (!existsSync(rootPath)) {
+    return [];
+  }
+  const stats = statSync(rootPath);
+  if (stats.isFile()) {
+    return rootPath.endsWith(".md") || rootPath.endsWith(".mdx") ? [rootPath] : [];
+  }
+  return readdirSync(rootPath, { withFileTypes: true }).flatMap((entry) => {
+    const fullPath = join(rootPath, entry.name);
+    if (entry.isDirectory()) {
+      return listMarkdownFiles(fullPath);
+    }
+    if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
+      return [fullPath];
+    }
+    return [];
+  }).sort((left, right) => left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" }));
+}
+class FilesystemContentSource {
+  constructor(tenantConfig) {
+    this.tenantConfig = tenantConfig;
+  }
+  tenantConfig;
+  async listEntries() {
+    const entries = [];
+    for (const [model, rootPath] of Object.entries(this.tenantConfig.content ?? {})) {
+      if (!rootPath) continue;
+      for (const filePath of listMarkdownFiles(String(rootPath))) {
+        const relativePath = normalizeRelativeMarkdownPath(filePath, String(rootPath));
+        const raw = readFileSync(filePath, "utf8");
+        const parsed = parseFrontmatterDocument(raw);
+        const searchText = markdownText(parsed.body);
+        const slug = normalizeSlug(model, relativePath, parsed.frontmatter);
+        entries.push({
+          model,
+          id: basename(filePath, extname(filePath)),
+          slug,
+          title: inferTitle(relativePath, parsed.frontmatter),
+          summary: inferSummary(parsed.frontmatter, searchText),
+          status: inferStatus(parsed.frontmatter),
+          visibility: inferVisibility(parsed.frontmatter),
+          frontmatter: parsed.frontmatter,
+          body: parsed.body,
+          relativePath,
+          filePath,
+          updatedAt: statSync(filePath).mtime.toISOString()
+        });
+      }
+    }
+    return entries;
+  }
+}
+class DefaultEntryRenderer {
+  async render(entry, context) {
+    const contentPayload = {
+      model: entry.model,
+      id: entry.id,
+      slug: entry.slug,
+      title: entry.title,
+      summary: entry.summary,
+      status: entry.status,
+      visibility: entry.visibility,
+      frontmatter: entry.frontmatter,
+      body: entry.body,
+      relativePath: entry.relativePath,
+      filePath: entry.filePath,
+      updatedAt: entry.updatedAt
+    };
+    const renderedPayload = {
+      format: "markdown",
+      body: entry.body
+    };
+    const searchText = markdownText(entry.body);
+    const searchPayload = {
+      model: entry.model,
+      id: entry.id,
+      slug: entry.slug,
+      title: entry.title,
+      summary: entry.summary,
+      text: searchText,
+      updatedAt: entry.updatedAt
+    };
+    const content = objectInputForJson(context.teamId, "objects", contentPayload);
+    const rendered = objectInputForJson(context.teamId, "objects", renderedPayload);
+    const search = objectInputForJson(context.teamId, "objects", searchPayload);
+    return {
+      entry: {
+        id: entry.id,
+        model: entry.model,
+        slug: entry.slug,
+        title: entry.title,
+        summary: entry.summary,
+        status: entry.status,
+        visibility: entry.visibility,
+        teamId: context.teamId,
+        publishedAt: context.generatedAt,
+        updatedAt: entry.updatedAt,
+        content: content.pointer,
+        rendered: rendered.pointer,
+        search: search.pointer,
+        metadata: {
+          relativePath: entry.relativePath,
+          ...entry.frontmatter
+        }
+      },
+      objects: [content.object, rendered.object, search.object],
+      searchText
+    };
+  }
+}
+class DefaultCollectionIndexBuilder {
+  async build(model, entries, context) {
+    const index = {
+      model,
+      generatedAt: context.generatedAt,
+      count: entries.length,
+      entries
+    };
+    const object = objectInputForJson(context.teamId, "objects", index);
+    return { index, object: object.object };
+  }
+}
+function buildDocsTree(entries) {
+  return entries.filter((entry) => entry.model === "docs").map((entry) => ({
+    id: entry.id,
+    slug: entry.slug,
+    title: entry.title,
+    summary: entry.summary,
+    path: entry.slug.startsWith("knowledge/") ? `/${entry.slug}/` : `/knowledge/${entry.slug}/`
+  }));
+}
+class DefaultRuntimeBundleBuilder {
+  async build(context, entries) {
+    const objects = [];
+    const runtime = {};
+    if (context.tenantConfig.content.books && existsSync(String(context.tenantConfig.content.books))) {
+      const booksRuntime = buildTenantBookRuntime(context.tenantConfig, {
+        projectRoot: context.projectRoot
+      });
+      const pointer = objectInputForJson(context.teamId, "objects", booksRuntime);
+      objects.push(pointer.object);
+      runtime.booksRuntime = pointer.pointer;
+      runtime.docsHomePath = booksRuntime.TREESEED_LINKS.home;
+    }
+    const docsTree = buildDocsTree(entries);
+    if (docsTree.length > 0) {
+      const pointer = objectInputForJson(context.teamId, "objects", docsTree);
+      objects.push(pointer.object);
+      runtime.docsTree = pointer.pointer;
+      runtime.docsHomePath = runtime.docsHomePath ?? "/knowledge/";
+    }
+    const searchIndex = entries.map((entry) => ({
+      id: `${entry.model}:${entry.id}`,
+      model: entry.model,
+      slug: entry.slug,
+      title: entry.title,
+      summary: entry.summary,
+      search: entry.search?.objectKey ?? null,
+      updatedAt: entry.updatedAt
+    }));
+    if (searchIndex.length > 0) {
+      const pointer = objectInputForJson(context.teamId, "objects", searchIndex);
+      objects.push(pointer.object);
+      runtime.searchIndex = pointer.pointer;
+    }
+    return { runtime, objects };
+  }
+}
+function collectGeneratedArtifacts(projectRoot) {
+  const outputRoot = resolve(projectRoot, "public", "books");
+  if (!existsSync(outputRoot)) {
+    return [];
+  }
+  return readdirSync(outputRoot).map((entry) => resolve(outputRoot, entry)).filter((filePath) => statSync(filePath).isFile() && extname(filePath).toLowerCase() === ".md").sort((left, right) => left.localeCompare(right));
+}
+class DefaultArtifactBuilder {
+  async build(context, entries) {
+    const artifacts = [];
+    const objects = [];
+    const catalog = [];
+    if (context.tenantConfig.content.books && existsSync(String(context.tenantConfig.content.books))) {
+      const runtime = buildTenantBookRuntime(context.tenantConfig, { projectRoot: context.projectRoot });
+      for (const book of runtime.BOOKS) {
+        await exportBookPackage(book.slug, { projectRoot: context.projectRoot });
+      }
+      await exportBookLibrary({ projectRoot: context.projectRoot });
+    }
+    for (const filePath of collectGeneratedArtifacts(context.projectRoot)) {
+      const artifact = objectInputForFile(context.teamId, filePath, "artifacts");
+      objects.push(artifact.object);
+      const itemId = basename(filePath, extname(filePath));
+      artifacts.push({
+        id: `${itemId}-${String(context.sourceCommit ?? "current").slice(0, 12) || context.generatedAt}`,
+        itemId,
+        kind: itemId === "treeseed-knowledge" ? "knowledge_pack" : "book_export",
+        version: String(context.sourceCommit ?? context.generatedAt).slice(0, 12) || context.generatedAt,
+        label: itemId,
+        visibility: "public",
+        teamId: context.teamId,
+        publishedAt: context.generatedAt,
+        content: artifact.pointer,
+        metadata: {
+          fileName: basename(filePath),
+          source: "generated"
+        }
+      });
+    }
+    for (const entry of entries.filter((candidate) => candidate.model === "templates")) {
+      const source = entry.metadata?.fulfillment?.source;
+      if (!source || source.kind !== "r2" || typeof source.objectKey !== "string" || typeof source.version !== "string") {
+        continue;
+      }
+      artifacts.push({
+        id: `${entry.slug}-${String(source.version)}`,
+        itemId: entry.slug,
+        kind: "template_artifact",
+        version: String(source.version),
+        label: entry.title ?? entry.slug,
+        visibility: entry.visibility,
+        teamId: context.teamId,
+        publishedAt: context.generatedAt,
+        content: {
+          objectKey: source.objectKey,
+          sha256: typeof source.integrity === "string" ? source.integrity : stableHash(source.objectKey),
+          contentType: "application/octet-stream",
+          publicUrl: typeof source.publicUrl === "string" ? source.publicUrl : void 0
+        },
+        metadata: {
+          manifestKey: resolveTeamScopedContentLocator(context.siteConfig, context.teamId).manifestKey,
+          source
+        }
+      });
+    }
+    for (const entry of entries.filter((candidate) => candidate.model === "templates" || candidate.model === "knowledge_packs")) {
+      catalog.push({
+        id: `${entry.model}:${entry.id}`,
+        teamId: context.teamId,
+        kind: entry.model === "templates" ? "template" : "knowledge_pack",
+        slug: entry.slug,
+        title: entry.title ?? entry.slug,
+        summary: entry.summary,
+        visibility: entry.visibility,
+        listingEnabled: entry.metadata?.listingEnabled !== false,
+        offerMode: typeof entry.metadata?.offer?.priceModel === "string" ? entry.metadata.offer.priceModel : "free",
+        manifestKey: resolveTeamScopedContentLocator(context.siteConfig, context.teamId).manifestKey,
+        artifactKey: void 0,
+        updatedAt: context.generatedAt,
+        searchText: [entry.title, entry.summary].filter(Boolean).join(" ").trim(),
+        metadata: entry.metadata
+      });
+    }
+    return { artifacts, objects, catalog };
+  }
+}
+function dedupeObjects(objects) {
+  const deduped = /* @__PURE__ */ new Map();
+  for (const object of objects) {
+    deduped.set(object.pointer.objectKey, object);
+  }
+  return [...deduped.values()];
+}
+function buildTombstones(previousManifest, nextEntries, generatedAt) {
+  const previousEntries = previousManifest?.entries ?? [];
+  const nextPaths = new Set(nextEntries.map((entry) => canonicalEntryPath(entry)));
+  return previousEntries.filter((entry) => !nextPaths.has(canonicalEntryPath(entry))).map((entry) => ({
+    path: canonicalEntryPath(entry),
+    removedAt: generatedAt,
+    previousSha256: entry.content.sha256
+  }));
+}
+function filterChangedEntries(previousManifest, nextEntries) {
+  const previous = new Map((previousManifest?.entries ?? []).map((entry) => [canonicalEntryPath(entry), entrySignature(entry)]));
+  return nextEntries.filter((entry) => previous.get(canonicalEntryPath(entry)) !== entrySignature(entry));
+}
+function filterChangedArtifacts(previousManifest, nextArtifacts) {
+  const previous = new Map((previousManifest?.artifacts ?? []).map((artifact) => [canonicalArtifactKey(artifact), artifactSignature(artifact)]));
+  return nextArtifacts.filter((artifact) => previous.get(canonicalArtifactKey(artifact)) !== artifactSignature(artifact));
+}
+function collectReferencedObjectKeys(entries, artifacts, runtime) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const entry of entries) {
+    keys.add(entry.content.objectKey);
+    if (entry.rendered?.objectKey) keys.add(entry.rendered.objectKey);
+    if (entry.search?.objectKey) keys.add(entry.search.objectKey);
+  }
+  for (const artifact of artifacts) {
+    keys.add(artifact.content.objectKey);
+  }
+  for (const pointer of [runtime?.booksRuntime, runtime?.docsTree, runtime?.searchIndex]) {
+    if (pointer?.objectKey) keys.add(pointer.objectKey);
+  }
+  return keys;
+}
+function changedRuntimePointers(previousManifest, nextRuntime) {
+  const changed = /* @__PURE__ */ new Set();
+  for (const key of ["booksRuntime", "docsTree", "searchIndex"]) {
+    const nextPointer = nextRuntime[key];
+    if (!nextPointer?.objectKey) {
+      continue;
+    }
+    const previousPointer = previousManifest?.runtime?.[key];
+    if (!previousPointer || previousPointer.sha256 !== nextPointer.sha256) {
+      changed.add(nextPointer.objectKey);
+    }
+  }
+  return changed;
+}
+function createFilesystemContentSource(tenantConfig) {
+  return new FilesystemContentSource(tenantConfig);
+}
+function createPublishedContentPipeline(context, options = {}) {
+  const contentSource = options.contentSource ?? createFilesystemContentSource(context.tenantConfig);
+  const entryRenderer = options.entryRenderer ?? new DefaultEntryRenderer();
+  const collectionIndexBuilder = options.collectionIndexBuilder ?? new DefaultCollectionIndexBuilder();
+  const runtimeBundleBuilder = options.runtimeBundleBuilder ?? new DefaultRuntimeBundleBuilder();
+  const artifactBuilder = options.artifactBuilder ?? new DefaultArtifactBuilder();
+  async function buildFullState() {
+    const sourceEntries = await contentSource.listEntries();
+    const renderedEntries = await Promise.all(sourceEntries.map((entry) => entryRenderer.render(entry, context)));
+    const entries = renderedEntries.map((entry) => entry.entry);
+    const objects = renderedEntries.flatMap((entry) => entry.objects);
+    const collections = /* @__PURE__ */ new Map();
+    for (const [model, modelEntries] of Object.entries(Object.groupBy(entries, (entry) => entry.model))) {
+      const actualEntries = (modelEntries ?? []).sort((left, right) => left.slug.localeCompare(right.slug));
+      const { object } = await collectionIndexBuilder.build(model, actualEntries, context);
+      collections.set(model, object.pointer);
+      objects.push(object);
+    }
+    const runtimeBundle = await runtimeBundleBuilder.build(context, entries);
+    objects.push(...runtimeBundle.objects);
+    const artifactBundle = await artifactBuilder.build(context, entries);
+    objects.push(...artifactBundle.objects);
+    return {
+      entries: entries.sort((left, right) => canonicalEntryPath(left).localeCompare(canonicalEntryPath(right))),
+      artifacts: artifactBundle.artifacts.sort((left, right) => canonicalArtifactKey(left).localeCompare(canonicalArtifactKey(right))),
+      runtime: runtimeBundle.runtime,
+      collections: Object.fromEntries(collections),
+      objects: dedupeObjects(objects),
+      catalog: artifactBundle.catalog ?? []
+    };
+  }
+  return {
+    async buildProductionRevision(options2 = {}) {
+      const state = await buildFullState();
+      const revisionSource = `${context.sourceRef ?? "content"}:${context.sourceCommit ?? context.generatedAt}`;
+      const revision = `${String(context.sourceRef ?? context.siteConfig.slug).replace(/[^a-zA-Z0-9._-]+/g, "-")}-${stableHash(revisionSource).slice(0, 12)}`;
+      return {
+        manifest: {
+          schemaVersion: PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
+          siteSlug: context.siteConfig.slug,
+          teamId: context.teamId,
+          revision,
+          generatedAt: context.generatedAt,
+          mode: "production",
+          sourceCommit: context.sourceCommit ?? void 0,
+          appRevision: context.sourceCommit ?? void 0,
+          locator: resolveTeamScopedContentLocator(context.siteConfig, context.teamId),
+          collections: state.collections,
+          entries: state.entries,
+          artifacts: state.artifacts,
+          runtime: state.runtime,
+          tombstones: buildTombstones(options2.previousManifest, state.entries, context.generatedAt),
+          metadata: {
+            publishedFromBranch: context.sourceRef,
+            publishedScope: "prod"
+          }
+        },
+        objects: state.objects,
+        catalog: state.catalog
+      };
+    },
+    async buildEditorialOverlay(options2) {
+      const state = await buildFullState();
+      const previousManifest = options2.previousManifest ?? null;
+      const changedEntries = filterChangedEntries(previousManifest, state.entries);
+      const changedArtifacts = filterChangedArtifacts(previousManifest, state.artifacts);
+      const tombstones = buildTombstones(previousManifest, state.entries, context.generatedAt);
+      const referencedKeys = collectReferencedObjectKeys(changedEntries, changedArtifacts, void 0);
+      for (const objectKey of changedRuntimePointers(previousManifest, state.runtime)) {
+        referencedKeys.add(objectKey);
+      }
+      const changedObjects = state.objects.filter((object) => referencedKeys.has(object.pointer.objectKey));
+      return {
+        overlay: {
+          schemaVersion: PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
+          siteSlug: context.siteConfig.slug,
+          teamId: context.teamId,
+          previewId: options2.previewId,
+          generatedAt: context.generatedAt,
+          mode: "editorial_overlay",
+          baseManifestKey: resolveTeamScopedContentLocator(context.siteConfig, context.teamId).manifestKey,
+          baseRevision: previousManifest?.revision,
+          sourceCommit: context.sourceCommit ?? void 0,
+          expiresAt: new Date(Date.now() + resolvePublishedContentPreviewTtlHours(context.siteConfig) * 60 * 60 * 1e3).toISOString(),
+          locator: resolveTeamScopedContentLocator(context.siteConfig, context.teamId, options2.previewId),
+          entries: changedEntries,
+          artifacts: changedArtifacts,
+          runtime: state.runtime,
+          tombstones,
+          metadata: {
+            publishedFromBranch: context.sourceRef,
+            publishedScope: "staging"
+          }
+        },
+        objects: dedupeObjects(changedObjects),
+        catalog: state.catalog
+      };
+    }
+  };
+}
+export {
+  createFilesystemContentSource,
+  createPublishedContentPipeline
+};