@treeseed/sdk 0.4.6 → 0.4.8

package/dist/operations/services/export-runtime.d.ts

@@ -0,0 +1,18 @@
+export type TreeseedExportResult = {
+    directory: string;
+    tenantRoot: string;
+    outputPath: string;
+    branch: string;
+    timestamp: string;
+    includedBundlePaths: string[];
+    ignorePatterns: string[];
+    summary: {
+        totalFiles: number;
+        totalCharacters: number;
+        totalTokens: number;
+        outputFiles: string[];
+    };
+};
+export declare function exportTreeseedCodebase({ directory, }?: {
+    directory?: string;
+}): Promise<TreeseedExportResult>;

package/dist/operations/services/export-runtime.js

@@ -0,0 +1,136 @@
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { resolve, relative } from "node:path";
+import { runDefaultAction, setLogLevel } from "repomix";
+import { loadTreeseedDeployConfigFromPath, resolveTreeseedDeployConfigPathFromRoot } from "../../platform/deploy-config.js";
+import { findNearestTreeseedRoot } from "./workspace-tools.js";
+import { currentBranch, repoRoot } from "./workspace-save.js";
+function ensureDirectory(directory) {
+  if (!existsSync(directory)) {
+    throw new Error(`Treeseed export directory does not exist: ${directory}`);
+  }
+  const stats = statSync(directory);
+  if (!stats.isDirectory()) {
+    throw new Error(`Treeseed export directory must be a directory: ${directory}`);
+  }
+}
+function formatExportTimestamp(date = /* @__PURE__ */ new Date()) {
+  const year = date.getFullYear();
+  const month = `${date.getMonth() + 1}`.padStart(2, "0");
+  const day = `${date.getDate()}`.padStart(2, "0");
+  const hours = `${date.getHours()}`.padStart(2, "0");
+  const minutes = `${date.getMinutes()}`.padStart(2, "0");
+  const seconds = `${date.getSeconds()}`.padStart(2, "0");
+  return `${year}-${month}-${day}-${hours}-${minutes}-${seconds}`;
+}
+function sanitizeBranchSegment(branch) {
+  const sanitized = String(branch ?? "").trim().replaceAll(/[\\/]+/g, "-").replaceAll(/[^a-zA-Z0-9._-]+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
+  return sanitized || "detached";
+}
+function resolveGitBranch(directory) {
+  try {
+    const gitRoot = repoRoot(directory);
+    const branch = currentBranch(gitRoot);
+    return sanitizeBranchSegment(branch);
+  } catch {
+    return "detached";
+  }
+}
+function resolveExportOutputPath(directory, branch, timestamp) {
+  const exportsRoot = resolve(directory, ".treeseed", "exports");
+  mkdirSync(exportsRoot, { recursive: true });
+  return resolve(exportsRoot, `${branch}-${timestamp}.md`);
+}
+function resolveConfiguredBundlePaths(directory, tenantRoot, config) {
+  const includedBundlePaths = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const configuredPath of config.export?.bundledPaths ?? []) {
+    const absolutePath = resolve(tenantRoot, configuredPath);
+    if (!existsSync(absolutePath)) {
+      continue;
+    }
+    const relativeToDirectory = relative(directory, absolutePath);
+    if (!relativeToDirectory || !relativeToDirectory.startsWith("..") && relativeToDirectory !== ".") {
+      continue;
+    }
+    if (seen.has(absolutePath)) {
+      continue;
+    }
+    seen.add(absolutePath);
+    includedBundlePaths.push(absolutePath);
+  }
+  return includedBundlePaths.sort((left, right) => left.localeCompare(right));
+}
+function resolveIgnorePatterns(config) {
+  return [
+    ".treeseed/exports",
+    ".treeseed/exports/**",
+    "**/.treeseed/exports",
+    "**/.treeseed/exports/**",
+    ...config.export?.ignore ?? []
+  ];
+}
+function toRepomixDirectories(directory, includedBundlePaths) {
+  return [".", ...includedBundlePaths.map((bundlePath) => relative(directory, bundlePath) || ".")];
+}
+function normalizePackResultOutputFiles(packResult, outputPath) {
+  return packResult.outputFiles && packResult.outputFiles.length > 0 ? packResult.outputFiles : [outputPath];
+}
+async function withCleanNodeExecArgv(action) {
+  const previousExecArgv = [...process.execArgv];
+  process.execArgv = previousExecArgv.filter(
+    (arg) => !arg.startsWith("--test") && !arg.startsWith("--input-type") && !arg.startsWith("--experimental-test") && !arg.startsWith("--watch")
+  );
+  try {
+    return await action();
+  } finally {
+    process.execArgv = previousExecArgv;
+  }
+}
+async function exportTreeseedCodebase({
+  directory = process.cwd()
+} = {}) {
+  const resolvedDirectory = resolve(directory);
+  ensureDirectory(resolvedDirectory);
+  const tenantRoot = findNearestTreeseedRoot(resolvedDirectory);
+  if (!tenantRoot) {
+    throw new Error(`Treeseed export requires a Treeseed project. No ancestor containing treeseed.site.yaml was found from ${resolvedDirectory}.`);
+  }
+  const deployConfig = loadTreeseedDeployConfigFromPath(resolveTreeseedDeployConfigPathFromRoot(tenantRoot));
+  const includedBundlePaths = resolveConfiguredBundlePaths(resolvedDirectory, tenantRoot, deployConfig);
+  const ignorePatterns = resolveIgnorePatterns(deployConfig);
+  const branch = resolveGitBranch(resolvedDirectory);
+  const timestamp = formatExportTimestamp();
+  const outputPath = resolveExportOutputPath(resolvedDirectory, branch, timestamp);
+  const options = {
+    output: outputPath,
+    style: "markdown",
+    ignore: ignorePatterns.join(","),
+    quiet: true,
+    skipLocalConfig: true,
+    copy: false,
+    stdout: false
+  };
+  setLogLevel(0);
+  const result = await withCleanNodeExecArgv(
+    () => runDefaultAction(toRepomixDirectories(resolvedDirectory, includedBundlePaths), resolvedDirectory, options)
+  );
+  const outputFiles = normalizePackResultOutputFiles(result.packResult, outputPath);
+  return {
+    directory: resolvedDirectory,
+    tenantRoot,
+    outputPath,
+    branch,
+    timestamp,
+    includedBundlePaths,
+    ignorePatterns,
+    summary: {
+      totalFiles: result.packResult.totalFiles,
+      totalCharacters: result.packResult.totalCharacters,
+      totalTokens: result.packResult.totalTokens,
+      outputFiles
+    }
+  };
+}
+export {
+  exportTreeseedCodebase
+};

package/dist/operations/services/template-registry.d.ts

@@ -37,6 +37,7 @@ export interface TemplateProductDefinition extends SdkTemplateCatalogEntry {
     artifactRoot: string;
     artifactManifestPath: string;
     templateRoot: string;
+    fulfillmentMode: 'packaged' | 'git';
 }
 export interface ResolvedTemplateDefinition {
     product: TemplateProductDefinition;
@@ -82,6 +83,7 @@ export declare function serializeTemplateRegistryEntry(product: Pick<TemplatePro
     templateApiVersion: number;
     minCliVersion: string;
     minCoreVersion: string | undefined;
+    fulfillmentMode: "git" | "packaged";
     source: import("../../sdk-types.ts").SdkTemplateCatalogSource;
 };
 export declare function exportTemplateCatalogYaml(options?: TemplateCatalogOptions): Promise<string>;

package/dist/operations/services/template-registry.js

@@ -1,4 +1,5 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 import { basename, dirname, relative, resolve } from "node:path";
 import { RemoteTemplateCatalogClient } from "../../template-catalog.js";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
@@ -53,10 +54,10 @@ function validateTemplateProductShape(product) {
   if (product.status !== "draft" && product.status !== "live" && product.status !== "archived") {
     throw new Error(`Template product ${product.id} uses unsupported status "${product.status}".`);
   }
-  if (!existsSync(product.artifactManifestPath)) {
+  if (product.fulfillmentMode === "packaged" && !existsSync(product.artifactManifestPath)) {
     throw new Error(`Template product ${product.id} points to a missing artifact manifest: ${product.artifactManifestPath}`);
   }
-  if (!existsSync(product.templateRoot)) {
+  if (product.fulfillmentMode === "packaged" && !existsSync(product.templateRoot)) {
     throw new Error(`Template product ${product.id} points to a missing template payload: ${product.templateRoot}`);
   }
 }
@@ -101,9 +102,55 @@ function normalizeTemplateProduct(remoteProduct) {
     contentPath: `${remoteProduct.fulfillment.source.repoUrl}#${remoteProduct.id}`,
     artifactRoot,
     artifactManifestPath: resolve(artifactRoot, "template.config.json"),
+    templateRoot: resolve(artifactRoot, "template"),
+    fulfillmentMode: remoteProduct.fulfillment.mode ?? "packaged"
+  };
+}
+function sanitizeCacheSegment(value) {
+  return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "source";
+}
+function resolveTemplateSourceCacheRoot(product, options) {
+  const cachePath = resolveTreeseedTemplateCatalogCachePath(options.cwd ?? process.cwd());
+  return resolve(dirname(cachePath), "templates", sanitizeCacheSegment(product.id), sanitizeCacheSegment(product.fulfillment.source.ref));
+}
+function runGit(commandArgs, cwd) {
+  const result = spawnSync("git", commandArgs, {
+    cwd,
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.trim() || result.stdout?.trim() || `git ${commandArgs.join(" ")} failed`);
+  }
+}
+function materializeGitTemplateSource(product, options) {
+  const cacheRoot = resolveTemplateSourceCacheRoot(product, options);
+  const repoRoot = resolve(cacheRoot, "repo");
+  const source = product.fulfillment.source;
+  if (!existsSync(resolve(repoRoot, ".git"))) {
+    rmSync(cacheRoot, { recursive: true, force: true });
+    mkdirSync(cacheRoot, { recursive: true });
+    runGit(["clone", "--no-checkout", source.repoUrl, repoRoot]);
+  }
+  runGit(["fetch", "--all", "--tags"], repoRoot);
+  runGit(["checkout", "--force", source.ref], repoRoot);
+  const artifactRoot = resolve(repoRoot, source.directory);
+  return {
+    artifactRoot,
+    manifestPath: resolve(artifactRoot, "template.config.json"),
     templateRoot: resolve(artifactRoot, "template")
   };
 }
+function resolveTemplateDefinitionPaths(product, options) {
+  if (existsSync(product.artifactManifestPath) && existsSync(product.templateRoot)) {
+    return {
+      artifactRoot: product.artifactRoot,
+      manifestPath: product.artifactManifestPath,
+      templateRoot: product.templateRoot
+    };
+  }
+  return materializeGitTemplateSource(product, options);
+}
 function readTemplateCatalogCache(cachePath) {
   if (!existsSync(cachePath)) {
     return null;
@@ -268,11 +315,12 @@ async function resolveTemplateDefinition(id, options = {}, category) {
     throw new Error(`Unable to resolve template "${id}" in category "${category}".`);
   }
   validateTemplateProductShape(product);
-  const manifest = loadJsonFile(product.artifactManifestPath);
+  const resolvedPaths = resolveTemplateDefinitionPaths(product, options);
+  const manifest = loadJsonFile(resolvedPaths.manifestPath);
   const definition = {
     product,
-    manifestPath: product.artifactManifestPath,
-    templateRoot: product.templateRoot,
+    manifestPath: resolvedPaths.manifestPath,
+    templateRoot: resolvedPaths.templateRoot,
     manifest
   };
   validateTemplateManifest(definition);
@@ -387,6 +435,7 @@ function serializeTemplateRegistryEntry(product) {
     templateApiVersion: product.templateApiVersion,
     minCliVersion: product.minCliVersion,
     minCoreVersion: product.minCoreVersion,
+    fulfillmentMode: product.fulfillment.mode ?? "packaged",
     source: product.fulfillment.source
   };
 }

package/dist/operations-registry.js

@@ -17,6 +17,7 @@ const TRESEED_OPERATION_SPECS = [
   operation({ id: "template.sync", name: "sync", aliases: [], group: "Validation", summary: "Validate or reconcile the managed template surface for the current site.", description: "Use remote template metadata plus the local scaffold artifact to check or apply updates to the managed scaffold surface.", provider: "default", related: ["template", "init", "status"] }),
   operation({ id: "project.init", name: "init", aliases: [], group: "Workflow", summary: "Scaffold a new Treeseed tenant project.", description: "Create a new Treeseed tenant directory from a remote-catalog template backed by the packaged scaffold artifact.", provider: "default", related: ["config", "switch", "dev"] }),
   operation({ id: "project.config", name: "config", aliases: [], group: "Workflow", summary: "Configure and test the runtime foundation.", description: "Apply safe repairs, collect environment values, write local machine config, generate local env files, initialize environments, sync providers, and run doctor-style checks.", provider: "default", related: ["status", "switch", "dev"] }),
+  operation({ id: "project.export", name: "export", aliases: [], group: "Utilities", summary: "Export a Markdown snapshot of the current codebase.", description: "Generate a Markdown codebase snapshot for the selected directory using the SDK-owned repomix integration and store it under .treeseed/exports.", provider: "default", related: ["status", "config"] }),
   operation({ id: "deploy.release", name: "release", aliases: [], group: "Workflow", summary: "Promote staging to production with a version bump.", description: "Validate staging, apply one version bump, tag the release, merge staging into main, push, and rely on production deploy automation.", provider: "default", related: ["stage", "status", "rollback"] }),
   operation({ id: "deploy.destroy", name: "destroy", aliases: [], group: "Workflow", summary: "Destroy a persistent environment and its local state.", description: "Delete the selected persistent environment resources and remove the local deploy state after confirmation.", provider: "default", related: ["config", "status"] }),
   operation({ id: "local.dev", name: "dev", aliases: [], group: "Local Development", summary: "Start the unified local Treeseed development environment.", description: "Start the unified local Treeseed development environment.", provider: "default" }),

package/dist/operations-types.d.ts

@@ -1,5 +1,5 @@
 export type TreeseedOperationGroup = 'Workflow' | 'Local Development' | 'Validation' | 'Release Utilities' | 'Utilities' | 'Passthrough';
-export type TreeseedOperationId = 'workspace.status' | 'workspace.doctor' | 'branch.tasks' | 'branch.switch' | 'branch.save' | 'branch.close' | 'branch.stage' | 'deploy.release' | 'deploy.rollback' | 'deploy.destroy' | 'template.list' | 'template.show' | 'template.validate' | 'template.sync' | 'project.init' | 'project.config' | 'local.dev' | 'local.devWatch' | 'local.build' | 'local.check' | 'local.preview' | 'local.lint' | 'local.test' | 'validation.testUnit' | 'validation.preflight' | 'validation.authCheck' | 'auth.login' | 'auth.logout' | 'auth.whoami' | 'release.testE2e' | 'release.testE2eLocal' | 'release.testE2eStaging' | 'release.testE2eFull' | 'release.testFast' | 'release.verify' | 'release.publishChanged' | 'services.mailpitUp' | 'services.mailpitDown' | 'services.mailpitLogs' | 'data.d1MigrateLocal' | 'content.cleanupMarkdown' | 'content.cleanupMarkdownCheck' | 'tools.astro' | 'tools.syncDevvars' | 'tools.starlightPatch' | 'agents.run';
+export type TreeseedOperationId = 'workspace.status' | 'workspace.doctor' | 'branch.tasks' | 'branch.switch' | 'branch.save' | 'branch.close' | 'branch.stage' | 'deploy.release' | 'deploy.rollback' | 'deploy.destroy' | 'template.list' | 'template.show' | 'template.validate' | 'template.sync' | 'project.init' | 'project.config' | 'local.dev' | 'local.devWatch' | 'local.build' | 'local.check' | 'local.preview' | 'local.lint' | 'local.test' | 'validation.testUnit' | 'validation.preflight' | 'validation.authCheck' | 'auth.login' | 'auth.logout' | 'auth.whoami' | 'release.testE2e' | 'release.testE2eLocal' | 'release.testE2eStaging' | 'release.testE2eFull' | 'release.testFast' | 'release.verify' | 'release.publishChanged' | 'services.mailpitUp' | 'services.mailpitDown' | 'services.mailpitLogs' | 'data.d1MigrateLocal' | 'content.cleanupMarkdown' | 'content.cleanupMarkdownCheck' | 'project.export' | 'tools.astro' | 'tools.syncDevvars' | 'tools.starlightPatch' | 'agents.run';
 export type TreeseedOperationProviderId = 'default';
 export type TreeseedOperationMetadata = {
     id: TreeseedOperationId;

package/dist/platform/book-export.d.ts

@@ -0,0 +1,78 @@
+export type TreeseedBookExportFileEntry = {
+    fileId: string;
+    bookId: string;
+    memberBookId: string;
+    absolutePath: string;
+    projectRelativePath: string;
+    bookRelativePath: string;
+    rootRelativePath: string;
+    rootPath: string;
+    ordinal: number;
+    frontmatterOrder: number | null;
+    sourceType: 'md' | 'mdx' | 'text';
+    chunkId: string;
+    markerId: string;
+};
+export type TreeseedBookExportMemberSummary = {
+    bookId: string;
+    slug: string;
+    title: string;
+    order: number;
+    downloadFileName: string;
+    downloadHref: string;
+    sourceFileCount: number;
+    markdownPath?: string;
+    indexPath?: string;
+};
+export type TreeseedBookExportManifest = {
+    packageKind: 'book' | 'library';
+    packageVersion: number;
+    packageId: string;
+    generatedAt: string;
+    tenantRoot: string;
+    tenantId: string;
+    book: {
+        id: string;
+        slug: string;
+        title: string;
+        order: number;
+        basePath: string;
+        downloadFileName: string;
+        downloadHref: string;
+        downloadTitle: string;
+        resolvedRoots: string[];
+    };
+    files: TreeseedBookExportFileEntry[];
+    members?: TreeseedBookExportMemberSummary[];
+};
+export type TreeseedBookPackageResult = {
+    manifest: TreeseedBookExportManifest;
+    markdownPath: string;
+    indexPath: string;
+    sourceFileCount: number;
+    includedRoots: string[];
+};
+export type TreeseedBookLibraryPackageResult = {
+    manifest: TreeseedBookExportManifest;
+    markdownPath: string;
+    indexPath: string;
+    memberPackages: TreeseedBookPackageResult[];
+    sourceFileCount: number;
+    includedRoots: string[];
+};
+export declare function buildBookExportManifest(bookId: string, options?: {
+    projectRoot?: string;
+}): TreeseedBookExportManifest;
+export declare function exportBookPackage(bookId: string, options?: {
+    projectRoot?: string;
+}): Promise<TreeseedBookPackageResult>;
+export declare function exportBookLibrary(options?: {
+    projectRoot?: string;
+}): Promise<TreeseedBookLibraryPackageResult>;
+export declare function exportTenantBookPackages(options?: {
+    projectRoot?: string;
+}): Promise<{
+    projectRoot: string;
+    bookPackages: TreeseedBookPackageResult[];
+    libraryPackage: TreeseedBookLibraryPackageResult;
+}>;