@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/platform/books-data.js

@@ -1,111 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import path from "node:path";
-import { parse as parseYaml } from "yaml";
-import { getTenantContentRoot } from "./tenant-config.js";
-import { RUNTIME_PROJECT_ROOT, RUNTIME_TENANT } from "./tenant/runtime-config.js";
-function fallbackTenantBookRuntime(options = {}) {
-  const docsHomePath = options.docsHomePath ?? "/books/";
-  const docsLibraryDownload = options.docsLibraryDownload ?? {
-    downloadFileName: "treeseed-knowledge.md",
-    downloadHref: "/books/treeseed-knowledge.md",
-    downloadTitle: "TreeSeed Knowledge Library"
-  };
-  return {
-    BOOKS: [],
-    BOOKS_LINK: {
-      label: "Books",
-      link: docsHomePath
-    },
-    TREESEED_LINKS: {
-      home: docsHomePath
-    },
-    TREESEED_LIBRARY_DOWNLOAD: docsLibraryDownload
-  };
-}
-function sortPaths(paths) {
-  return [...paths].sort((left, right) => left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" }));
-}
-function collectMarkdownFiles(rootPath) {
-  if (!existsSync(rootPath)) {
-    return [];
-  }
-  const stats = statSync(rootPath);
-  if (stats.isFile()) {
-    return [rootPath];
-  }
-  return sortPaths(
-    readdirSync(rootPath, { withFileTypes: true }).flatMap((entry) => {
-      const fullPath = path.join(rootPath, entry.name);
-      if (entry.isDirectory()) {
-        return collectMarkdownFiles(fullPath);
-      }
-      if (entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
-        return [fullPath];
-      }
-      return [];
-    })
-  );
-}
-function parseFrontmatter(filePath) {
-  const raw = readFileSync(filePath, "utf8");
-  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) {
-    throw new Error(`Book content entry is missing frontmatter: ${filePath}`);
-  }
-  return parseYaml(match[1]);
-}
-function inferDocsLibraryDownload(book) {
-  const title = book?.title ? `${book.title} Library` : "Knowledge Library";
-  return {
-    downloadFileName: "treeseed-knowledge.md",
-    downloadHref: "/books/treeseed-knowledge.md",
-    downloadTitle: title
-  };
-}
-function buildTenantBookRuntime(tenantConfig, options = {}) {
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const booksContentRoot = path.resolve(projectRoot, getTenantContentRoot(tenantConfig, "books"));
-  const books = collectMarkdownFiles(booksContentRoot).map((filePath) => {
-    const frontmatter = parseFrontmatter(filePath);
-    return {
-      ...frontmatter,
-      id: path.basename(filePath, path.extname(filePath))
-    };
-  }).sort((left, right) => left.order - right.order);
-  const docsHomePath = options.docsHomePath ?? "/books/";
-  const docsLibraryDownload = options.docsLibraryDownload ?? inferDocsLibraryDownload(tenantConfig);
-  return {
-    BOOKS: books,
-    BOOKS_LINK: {
-      label: "Books",
-      link: docsHomePath
-    },
-    TREESEED_LINKS: {
-      home: docsHomePath
-    },
-    TREESEED_LIBRARY_DOWNLOAD: docsLibraryDownload
-  };
-}
-const runtime = (() => {
-  const docsLibraryDownload = {
-    downloadFileName: "treeseed-knowledge.md",
-    downloadHref: "/books/treeseed-knowledge.md",
-    downloadTitle: "TreeSeed Knowledge Library"
-  };
-  try {
-    return buildTenantBookRuntime(RUNTIME_TENANT, {
-      projectRoot: RUNTIME_PROJECT_ROOT,
-      docsLibraryDownload
-    });
-  } catch {
-    return fallbackTenantBookRuntime({ docsLibraryDownload });
-  }
-})();
-const { BOOKS, BOOKS_LINK, TREESEED_LINKS, TREESEED_LIBRARY_DOWNLOAD } = runtime;
-export {
-  BOOKS,
-  BOOKS_LINK,
-  TREESEED_LIBRARY_DOWNLOAD,
-  TREESEED_LINKS,
-  buildTenantBookRuntime
-};

package/dist/platform/config.d.ts

@@ -1,27 +0,0 @@
-import { discoverTreeseedApplications } from '../hosting/apps.js';
-import { discoverTreeseedPackageAdapters } from '../operations/services/package-adapters.js';
-import { collectTreeseedEnvironmentContext } from '../operations/services/config-runtime.js';
-import type { TreeseedDeployConfig } from './contracts.js';
-export type TreeseedPlatformConfigInput = {
-    tenantRoot: string;
-    environment: 'local' | 'staging' | 'prod';
-    env?: Record<string, string | undefined>;
-    capacityConfigPath?: string | null;
-};
-declare function loadCapacityLaunchFromPackageManifest(tenantRoot: string): {
-    path: string;
-    manifest: import("../capacity-provider.js").CapacityProviderLaunchManifest;
-    plan: import("../capacity-provider.js").CapacityProviderLaunchPlan;
-} | null;
-declare function loadTreeseedDevManifest(tenantRoot: string): Record<string, unknown>;
-export declare function loadTreeseedPlatformConfig(input: TreeseedPlatformConfigInput): {
-    tenantRoot: string;
-    environment: 'local' | 'staging' | 'prod';
-    deployConfig: TreeseedDeployConfig;
-    packages: ReturnType<typeof discoverTreeseedPackageAdapters>;
-    applications: ReturnType<typeof discoverTreeseedApplications>;
-    capacityLaunch: ReturnType<typeof loadCapacityLaunchFromPackageManifest>;
-    dev: ReturnType<typeof loadTreeseedDevManifest>;
-    envRegistry: ReturnType<typeof collectTreeseedEnvironmentContext> | null;
-};
-export {};

package/dist/platform/config.js

@@ -1,100 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { parse as parseYaml } from "yaml";
-import { parseCapacityProviderLaunchManifest, resolveCapacityProviderLaunchPlan } from "../capacity-provider.js";
-import { discoverTreeseedApplications } from "../hosting/apps.js";
-import { discoverTreeseedPackageAdapters } from "../operations/services/package-adapters.js";
-import { collectTreeseedEnvironmentContext } from "../operations/services/config-runtime.js";
-import { loadTreeseedDeployConfigFromPath, resolveTreeseedDeployConfigPathFromRoot } from "./deploy-config.js";
-function loadOptionalYaml(filePath) {
-  if (!existsSync(filePath)) return null;
-  return parseYaml(readFileSync(filePath, "utf8"));
-}
-function loadCapacityLaunchFromPackageManifest(tenantRoot) {
-  const agentManifestPath = resolve(tenantRoot, "packages", "agent", "treeseed.package.yaml");
-  const manifest = loadOptionalYaml(agentManifestPath);
-  const capacityProvider = manifest?.capacityProvider;
-  if (!capacityProvider || typeof capacityProvider !== "object" || Array.isArray(capacityProvider)) return null;
-  const local = capacityProvider.local ?? {};
-  const roles = capacityProvider.roles ?? {};
-  const launchManifest = {
-    schemaVersion: 1,
-    provider: {
-      dataDir: local.dataDir ?? ".treeseed/local-capacity-provider/data",
-      environment: "local"
-    },
-    runtime: {
-      images: {
-        roles: {
-          manager: { image: roles.manager?.image ?? "treeseed/agent-manager", tag: roles.manager?.tag ?? "latest" },
-          runner: { image: roles.runner?.image ?? "treeseed/agent-runner", tag: roles.runner?.tag ?? "latest" }
-        }
-      }
-    }
-  };
-  const parsed = parseCapacityProviderLaunchManifest(launchManifest);
-  return {
-    path: agentManifestPath,
-    manifest: parsed,
-    plan: resolveCapacityProviderLaunchPlan(parsed)
-  };
-}
-function loadCapacityLaunchFromPath(configPath) {
-  if (!configPath) return null;
-  const absolutePath = resolve(configPath);
-  if (!existsSync(absolutePath)) {
-    throw new Error(`Capacity launch config was not found: ${absolutePath}`);
-  }
-  const parsed = parseCapacityProviderLaunchManifest(readFileSync(absolutePath, "utf8"));
-  return {
-    path: absolutePath,
-    manifest: parsed,
-    plan: resolveCapacityProviderLaunchPlan(parsed)
-  };
-}
-function loadTreeseedDevManifest(tenantRoot) {
-  return loadOptionalYaml(resolve(tenantRoot, "treeseed.dev.yaml")) ?? {
-    schemaVersion: 1,
-    dev: {
-      processes: {
-        "market-web": { package: "@treeseed/market", cwd: ".", surface: "web" },
-        api: { package: "@treeseed/api", cwd: "packages/api", surface: "api" },
-        "operations-runner": { package: "@treeseed/api", cwd: "packages/api", surface: "operations-runner" }
-      }
-    }
-  };
-}
-function discoverPlatformPackages(tenantRoot) {
-  if (!existsSync(resolve(tenantRoot, "package.json"))) {
-    return [];
-  }
-  return discoverTreeseedPackageAdapters(tenantRoot);
-}
-function loadTreeseedPlatformConfig(input) {
-  const tenantRoot = resolve(input.tenantRoot);
-  const deployConfigPath = resolveTreeseedDeployConfigPathFromRoot(tenantRoot);
-  const deployConfig = loadTreeseedDeployConfigFromPath(deployConfigPath);
-  const packages = discoverPlatformPackages(tenantRoot);
-  const applications = discoverTreeseedApplications(tenantRoot);
-  const capacityLaunch = loadCapacityLaunchFromPath(input.capacityConfigPath ?? input.env?.TREESEED_CAPACITY_CONFIG_PATH) ?? loadCapacityLaunchFromPackageManifest(tenantRoot);
-  const dev = loadTreeseedDevManifest(tenantRoot);
-  let envRegistry = null;
-  try {
-    envRegistry = collectTreeseedEnvironmentContext(tenantRoot, input.environment, { env: input.env });
-  } catch {
-    envRegistry = null;
-  }
-  return {
-    tenantRoot,
-    environment: input.environment,
-    deployConfig,
-    packages,
-    applications,
-    capacityLaunch,
-    dev,
-    envRegistry
-  };
-}
-export {
-  loadTreeseedPlatformConfig
-};

package/dist/platform/content-runtime-source.d.ts

@@ -1,54 +0,0 @@
-import type { SeedContentRuntimeSource, SeedProjectArchitecture } from '../seeds/types.js';
-export type TreeseedEffectiveContentSource = SeedContentRuntimeSource | 'missing';
-export type TreeseedContentRuntimeMode = 'local' | 'treedx' | 'r2' | 'missing';
-export type TreeseedContentRuntimeDiagnosticStatus = 'ready' | 'missing' | 'site_not_prepared' | 'unsupported_structure';
-export type TreeseedContentRuntimeDiagnostic = {
-    code: string;
-    status: TreeseedContentRuntimeDiagnosticStatus;
-    source: TreeseedContentRuntimeMode;
-    summary: string;
-    relativePath?: string;
-};
-export type TreeseedLocalContentRuntimeSummary = {
-    requestedLocalContentMode?: 'auto' | 'none' | 'preview' | 'edit' | string;
-    materializationStatus?: string | null;
-    effectiveLocalPath?: string | null;
-    localPathExists?: boolean;
-};
-export type TreeseedR2ContentRuntimeMetadata = {
-    manifestKey?: string | null;
-    overlayKey?: string | null;
-    revision?: string | null;
-};
-export type TreeseedTreeDxContentRuntimeMetadata = {
-    libraryId?: string | null;
-    repositoryId?: string | null;
-    snapshotId?: string | null;
-};
-export type TreeseedContentRuntimeResolution = {
-    contentRuntimeSource: SeedContentRuntimeSource;
-    effectiveContentSource: TreeseedEffectiveContentSource;
-    mode: TreeseedContentRuntimeMode;
-    ready: boolean;
-    manifestKey: string | null;
-    overlayKey: string | null;
-    revision: string | null;
-    snapshotId: string | null;
-    diagnostics: TreeseedContentRuntimeDiagnostic[];
-    localPath?: string | null;
-};
-export declare function resolveTreeseedContentRuntimeSource(input: {
-    architecture: Pick<SeedProjectArchitecture, 'contentRuntimeSource' | 'contentPublishTarget'>;
-    local?: TreeseedLocalContentRuntimeSummary | null;
-    r2?: TreeseedR2ContentRuntimeMetadata | null;
-    treeDx?: TreeseedTreeDxContentRuntimeMetadata | null;
-    includeLocalPath?: boolean;
-}): TreeseedContentRuntimeResolution;
-export declare function inspectTreeseedContentStructure(input: {
-    projectRoot: string;
-    architecture: Pick<SeedProjectArchitecture, 'rootPath' | 'sitePath' | 'contentPath'>;
-}): TreeseedContentRuntimeDiagnostic;
-export declare function contentRuntimeMetadataFromTarget(target: unknown): {
-    r2: TreeseedR2ContentRuntimeMetadata;
-    treeDx: TreeseedTreeDxContentRuntimeMetadata;
-};

package/dist/platform/content-runtime-source.js

@@ -1,169 +0,0 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { resolve } from "node:path";
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function text(value, fallback = "") {
-  return typeof value === "string" && value.trim() ? value.trim() : fallback;
-}
-function cleanRelativePath(value, fallback = ".") {
-  const raw = text(value, fallback).replace(/\\/gu, "/").replace(/^\/+/u, "");
-  const parts = raw.split("/").filter((part) => part && part !== ".");
-  if (parts.some((part) => part === "..")) return fallback;
-  return parts.length > 0 ? parts.join("/") : ".";
-}
-function contentRuntimeMode(source) {
-  if (source === "local_directory") return "local";
-  if (source === "treedx_snapshot") return "treedx";
-  if (source === "r2_published_manifest" || source === "r2_preview_overlay") return "r2";
-  return "missing";
-}
-function localStatusReady(status) {
-  return status === "existing_path_ready" || status === "managed_clone_ready" || status === "submodule_ready";
-}
-function localContentRequested(architecture, local) {
-  const mode = local?.requestedLocalContentMode;
-  return architecture.contentRuntimeSource === "local_directory" || mode === "preview" || mode === "edit";
-}
-function defaultManifestKey(architecture) {
-  const target = architecture.contentPublishTarget;
-  return target?.kind === "cloudflare_r2" && typeof target.manifestPath === "string" && target.manifestPath.trim() ? target.manifestPath.trim() : null;
-}
-function resolveTreeseedContentRuntimeSource(input) {
-  const diagnostics = [];
-  const localReady = input.local?.localPathExists === true || localStatusReady(input.local?.materializationStatus);
-  const localSelected = localReady && localContentRequested(input.architecture, input.local);
-  const source = localSelected ? "local_directory" : input.architecture.contentRuntimeSource ?? "r2_published_manifest";
-  const mode = contentRuntimeMode(source);
-  const manifestKey = input.r2?.manifestKey ?? defaultManifestKey(input.architecture);
-  const overlayKey = source === "r2_preview_overlay" ? input.r2?.overlayKey ?? null : null;
-  const snapshotId = source === "treedx_snapshot" ? input.treeDx?.snapshotId ?? null : null;
-  const revision = source === "r2_published_manifest" || source === "r2_preview_overlay" ? input.r2?.revision ?? null : null;
-  if (source === "local_directory") {
-    diagnostics.push({
-      code: localReady ? "local_content_ready" : "local_content_missing",
-      status: localReady ? "ready" : "missing",
-      source: "local",
-      summary: localReady ? "Local content path is available for runtime preview." : "Local content path is not available."
-    });
-  } else if (source === "treedx_snapshot") {
-    const ready = Boolean(snapshotId || input.treeDx?.libraryId || input.treeDx?.repositoryId);
-    diagnostics.push({
-      code: ready ? "treedx_snapshot_ready" : "treedx_snapshot_missing",
-      status: ready ? "ready" : "missing",
-      source: "treedx",
-      summary: ready ? "TreeDX content snapshot metadata is available." : "TreeDX content snapshot metadata is missing."
-    });
-  } else if (source === "r2_published_manifest" || source === "r2_preview_overlay") {
-    const ready = Boolean(manifestKey);
-    diagnostics.push({
-      code: ready ? "r2_manifest_ready" : "r2_manifest_missing",
-      status: ready ? "ready" : "missing",
-      source: "r2",
-      summary: ready ? "R2 published content manifest metadata is available." : "R2 published content manifest metadata is missing."
-    });
-    if (source === "r2_preview_overlay" && !overlayKey) {
-      diagnostics.push({
-        code: "r2_preview_overlay_missing",
-        status: "missing",
-        source: "r2",
-        summary: "R2 preview overlay metadata is missing."
-      });
-    }
-  }
-  return {
-    contentRuntimeSource: input.architecture.contentRuntimeSource,
-    effectiveContentSource: source,
-    mode,
-    ready: diagnostics.every((entry) => entry.status === "ready"),
-    manifestKey,
-    overlayKey,
-    revision,
-    snapshotId,
-    diagnostics,
-    ...input.includeLocalPath ? { localPath: input.local?.effectiveLocalPath ?? null } : {}
-  };
-}
-function hasMarkdownFile(root) {
-  if (!existsSync(root)) return false;
-  const stats = statSync(root);
-  if (stats.isFile()) return root.endsWith(".md") || root.endsWith(".mdx");
-  if (!stats.isDirectory()) return false;
-  return readdirSync(root, { withFileTypes: true }).some((entry) => {
-    const fullPath = resolve(root, entry.name);
-    if (entry.isDirectory()) return hasMarkdownFile(fullPath);
-    return entry.isFile() && (entry.name.endsWith(".md") || entry.name.endsWith(".mdx"));
-  });
-}
-function inspectTreeseedContentStructure(input) {
-  const rootPath = cleanRelativePath(input.architecture.rootPath);
-  const sitePath = cleanRelativePath(input.architecture.sitePath);
-  const contentPath = input.architecture.contentPath ? cleanRelativePath(input.architecture.contentPath) : null;
-  const siteRoot = resolve(input.projectRoot, rootPath === "." ? "" : rootPath, sitePath === "." ? "" : sitePath);
-  if (!existsSync(siteRoot)) {
-    return {
-      code: "site_not_prepared",
-      status: "site_not_prepared",
-      source: "local",
-      summary: "Site path is not prepared yet.",
-      relativePath: sitePath
-    };
-  }
-  const candidatePaths = [
-    contentPath,
-    sitePath === "." ? "src/content" : `${sitePath}/src/content`,
-    sitePath,
-    "content"
-  ].filter((entry) => Boolean(entry));
-  for (const candidate of [...new Set(candidatePaths)]) {
-    const absolute = resolve(input.projectRoot, rootPath === "." ? "" : rootPath, candidate === "." ? "" : candidate);
-    if (!existsSync(absolute)) continue;
-    if (hasMarkdownFile(absolute)) {
-      return {
-        code: "content_structure_ready",
-        status: "ready",
-        source: "local",
-        summary: "Content structure contains Markdown or MDX files.",
-        relativePath: candidate
-      };
-    }
-    return {
-      code: "unsupported_content_structure",
-      status: "unsupported_structure",
-      source: "local",
-      summary: "Content path exists but does not contain Markdown or MDX files.",
-      relativePath: candidate
-    };
-  }
-  return {
-    code: "content_structure_missing",
-    status: "missing",
-    source: "local",
-    summary: "No supported local content path was found.",
-    relativePath: contentPath ?? "src/content"
-  };
-}
-function contentRuntimeMetadataFromTarget(target) {
-  const record = isRecord(target) ? target : {};
-  const contentRuntime = isRecord(record.contentRuntime) ? record.contentRuntime : {};
-  const contentPublish = isRecord(record.contentPublish) ? record.contentPublish : {};
-  const r2 = isRecord(contentRuntime.r2) ? contentRuntime.r2 : isRecord(contentPublish.r2) ? contentPublish.r2 : {};
-  const treeDx = isRecord(contentRuntime.treeDx) ? contentRuntime.treeDx : contentPublish.provider === "treedx" ? contentPublish : {};
-  return {
-    r2: {
-      manifestKey: text(contentRuntime.manifestKey) || text(r2.manifestKey) || text(r2.manifestPath) || null,
-      overlayKey: text(contentRuntime.overlayKey) || text(r2.overlayKey) || null,
-      revision: text(contentRuntime.revision) || text(r2.revision) || null
-    },
-    treeDx: {
-      libraryId: text(treeDx.libraryId) || null,
-      repositoryId: text(treeDx.repositoryId) || null,
-      snapshotId: text(treeDx.snapshotId) || text(contentPublish.snapshotId) || null
-    }
-  };
-}
-export {
-  contentRuntimeMetadataFromTarget,
-  inspectTreeseedContentStructure,
-  resolveTreeseedContentRuntimeSource
-};