@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/operations/services/local-cleanup.js

@@ -1,77 +0,0 @@
-import { existsSync, readdirSync, rmSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
-function directoryBytes(path) {
-  if (!existsSync(path)) return 0;
-  const stat = statSync(path, { throwIfNoEntry: false });
-  if (!stat) return 0;
-  if (!stat.isDirectory()) return stat.size;
-  let total = stat.size;
-  for (const entry of readdirSync(path)) total += directoryBytes(join(path, entry));
-  return total;
-}
-function removeDirectory(root, relativePath) {
-  const path = join(root, relativePath);
-  return removeDirectoryPath(relativePath, path);
-}
-function removeDirectoryPath(id, path) {
-  const beforeBytes = directoryBytes(path);
-  if (!existsSync(path)) return { id, kind: "directory", path, status: "skipped", beforeBytes: 0, afterBytes: 0 };
-  try {
-    rmSync(path, { recursive: true, force: true });
-    return { id, kind: "directory", path, status: "removed", beforeBytes, afterBytes: directoryBytes(path) };
-  } catch (error) {
-    return { id, kind: "directory", path, status: "failed", beforeBytes, afterBytes: directoryBytes(path), error: error instanceof Error ? error.message : String(error) };
-  }
-}
-function workspaceRepositoryRoots(root) {
-  const packagesRoot = join(root, "packages");
-  if (!existsSync(packagesRoot)) return [];
-  return readdirSync(packagesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join(packagesRoot, entry.name)).filter((path) => existsSync(join(path, ".git")) || existsSync(join(path, "package.json")) || existsSync(join(path, "treeseed.package.yaml")));
-}
-function runCleanupCommand(id, kind, command, cwd) {
-  const result = spawnSync(command[0], command.slice(1), { cwd, encoding: "utf8", maxBuffer: 1024 * 1024 * 16 });
-  const exitCode = result.status ?? null;
-  return {
-    id,
-    kind,
-    command,
-    status: exitCode === 0 ? "removed" : "failed",
-    exitCode,
-    ...exitCode === 0 ? {} : { error: (result.stderr || result.stdout || result.error?.message || "cleanup command failed").trim() }
-  };
-}
-function runTreeseedLocalCleanup(input) {
-  const root = resolve(input.root);
-  const mode = input.mode ?? "standard";
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const npmCacheRoot = resolve(input.npmCacheRoot ?? process.env.npm_config_cache ?? process.env.NPM_CONFIG_CACHE ?? join(homedir(), ".npm"));
-  const npmTemporaryDownloads = join(npmCacheRoot, "_cacache", "tmp");
-  const repositoryRoots = [root, ...workspaceRepositoryRoots(root)];
-  const beforeBytes = repositoryRoots.reduce((total, repositoryRoot) => total + directoryBytes(join(repositoryRoot, ".treeseed")), 0) + directoryBytes(npmTemporaryDownloads);
-  const actions = [];
-  const directoryTargets = mode === "aggressive" ? [
-    ".treeseed/tmp",
-    ".treeseed/cache",
-    ".treeseed/scenes/render"
-  ] : [".treeseed/tmp", ".treeseed/cache", ".treeseed/scenes/render"];
-  for (const repositoryRoot of repositoryRoots) {
-    const repositoryId = repositoryRoot === root ? "" : `${repositoryRoot.slice(root.length + 1)}:`;
-    for (const target of directoryTargets) {
-      actions.push(removeDirectoryPath(`${repositoryId}${target}`, join(repositoryRoot, target)));
-    }
-  }
-  actions.push(removeDirectoryPath("npm-cache-temporary-downloads", npmTemporaryDownloads));
-  if (input.docker === true && mode === "aggressive") {
-    actions.push(runCleanupCommand("docker-builder-prune", "docker", ["docker", "builder", "prune", "--all", "--force"], root));
-    actions.push(runCleanupCommand("docker-image-prune", "docker", ["docker", "image", "prune", "--all", "--force"], root));
-  }
-  if (input.npmCache === true) actions.push(runCleanupCommand("npm-cache-clean", "npm-cache", ["npm", "cache", "clean", "--force"], root));
-  const afterBytes = repositoryRoots.reduce((total, repositoryRoot) => total + directoryBytes(join(repositoryRoot, ".treeseed")), 0) + directoryBytes(npmTemporaryDownloads);
-  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
-  return { ok: actions.every((entry) => entry.status !== "failed"), mode, root, startedAt, completedAt, beforeBytes, afterBytes, reclaimedBytes: Math.max(0, beforeBytes - afterBytes), actions };
-}
-export {
-  runTreeseedLocalCleanup
-};

package/dist/operations/services/local-dev.d.ts

@@ -1,8 +0,0 @@
-export declare function runStep(command: any, args: any, options?: {}): void;
-export declare function runNodeScript(scriptRelativePath: any, args?: never[], options?: {}): void;
-export declare function spawnProcess(command: any, args: any, options?: {}): import("child_process").ChildProcessWithoutNullStreams;
-export declare function runLocalD1Migration(persistTo: any): void;
-export declare function prepareCloudflareLocalRuntime({ envOverrides, persistTo, outDir }?: {
-    envOverrides?: {} | undefined;
-}): void;
-export declare function startWranglerDev(args?: never[], options?: {}): import("child_process").ChildProcessWithoutNullStreams;

package/dist/operations/services/local-dev.js

@@ -1,97 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import { resolve } from "node:path";
-import { runLocalD1Migrations as applyLocalD1Migrations } from "./d1-migration.js";
-import {
-  fixtureRoot,
-  fixtureWranglerConfig,
-  corePackageRoot,
-  sdkD1MigrationsRoot
-} from "./runtime-paths.js";
-import { resolveTreeseedToolCommand } from "../../managed-dependencies.js";
-function mergeEnv(extraEnv = {}) {
-  return { ...process.env, ...extraEnv };
-}
-function runStep(command, args, options = {}) {
-  const result = spawnSync(command, args, {
-    stdio: "inherit",
-    shell: process.platform === "win32",
-    env: mergeEnv(options.env),
-    cwd: options.cwd ?? process.cwd()
-  });
-  if (result.status !== 0) {
-    process.exit(result.status ?? 1);
-  }
-}
-function runNodeScript(scriptRelativePath, args = [], options = {}) {
-  return runStep(process.execPath, [resolve(corePackageRoot, scriptRelativePath), ...args], {
-    ...options,
-    cwd: options.cwd ?? corePackageRoot
-  });
-}
-function spawnProcess(command, args, options = {}) {
-  return spawn(command, args, {
-    stdio: options.stdio ?? "inherit",
-    shell: process.platform === "win32",
-    env: mergeEnv(options.env),
-    cwd: options.cwd ?? process.cwd(),
-    detached: options.detached ?? false
-  });
-}
-function runLocalD1Migration(persistTo) {
-  applyLocalD1Migrations({
-    cwd: fixtureRoot,
-    wranglerConfig: fixtureWranglerConfig,
-    migrationsRoot: sdkD1MigrationsRoot,
-    persistTo
-  });
-}
-function prepareCloudflareLocalRuntime({ envOverrides = {}, persistTo, outDir } = {}) {
-  const mergedEnvOverrides = {
-    TREESEED_SMTP_HOST: "127.0.0.1",
-    TREESEED_SMTP_PORT: "1025",
-    ...envOverrides
-  };
-  runNodeScript("./scripts/patch-starlight-content-path.js");
-  runNodeScript("./scripts/aggregate-book.js");
-  runLocalD1Migration(persistTo);
-  const astroArgs = ["astro", "build", "--root", fixtureRoot];
-  if (outDir) {
-    astroArgs.push("--outDir", outDir);
-  }
-  runStep("npx", astroArgs, {
-    env: {
-      TREESEED_LOCAL_DEV_MODE: "cloudflare",
-      ...mergedEnvOverrides
-    },
-    cwd: corePackageRoot
-  });
-  runNodeScript("./scripts/build-tenant-worker.js", [], {
-    cwd: fixtureRoot,
-    env: {
-      TREESEED_LOCAL_DEV_MODE: "cloudflare",
-      ...mergedEnvOverrides
-    }
-  });
-}
-function startWranglerDev(args = [], options = {}) {
-  const wrangler = resolveTreeseedToolCommand("wrangler");
-  if (!wrangler) {
-    throw new Error("Wrangler CLI is unavailable.");
-  }
-  return spawnProcess(
-    wrangler.command,
-    [...wrangler.argsPrefix, "dev", "--local", "--config", fixtureWranglerConfig, ...args],
-    {
-      ...options,
-      cwd: options.cwd ?? fixtureRoot
-    }
-  );
-}
-export {
-  prepareCloudflareLocalRuntime,
-  runLocalD1Migration,
-  runNodeScript,
-  runStep,
-  spawnProcess,
-  startWranglerDev
-};

package/dist/operations/services/managed-host-security.d.ts

@@ -1,13 +0,0 @@
-import type { TreeseedDeployConfig } from '../../platform/contracts.js';
-export declare const MANAGED_HOST_DIRECT_CI_OPT_IN_ENV = "TREESEED_ALLOW_MANAGED_HOST_DIRECT_CI_SECRETS";
-export declare function allowsManagedHostDirectCiSecrets(env?: Record<string, string | undefined>): boolean;
-export declare function isTreeseedManagedHostedProject(deployConfig: Pick<TreeseedDeployConfig, 'hosting' | 'hub' | 'runtime'> | null | undefined): boolean;
-export declare function usesManagedHostOperationRequests(deployConfig: Pick<TreeseedDeployConfig, 'hosting' | 'hub' | 'runtime'> | null | undefined, env?: Record<string, string | undefined>): boolean;
-export declare function filterManagedHostGitHubEnvironment(required: {
-    secrets: string[];
-    variables: string[];
-}): {
-    secrets: string[];
-    variables: string[];
-};
-export declare function shouldExposeManagedHostRuntimeSecret(deployConfig: Pick<TreeseedDeployConfig, 'hosting' | 'hub' | 'runtime'> | null | undefined, _secretName: string, env?: Record<string, string | undefined>): boolean;

package/dist/operations/services/managed-host-security.js

@@ -1,56 +0,0 @@
-const MANAGED_HOST_DIRECT_CI_OPT_IN_ENV = "TREESEED_ALLOW_MANAGED_HOST_DIRECT_CI_SECRETS";
-const SAFE_MANAGED_HOST_CI_VARIABLES = /* @__PURE__ */ new Set([
-  "TREESEED_CATALOG_MARKET_API_BASE_URLS",
-  "TREESEED_CENTRAL_MARKET_API_BASE_URL",
-  "TREESEED_HOSTING_KIND",
-  "TREESEED_HOSTING_REGISTRATION",
-  "TREESEED_HOSTING_TEAM_ID",
-  "TREESEED_API_BASE_URL",
-  "TREESEED_PROJECT_ID"
-]);
-const SAFE_MANAGED_HOST_CI_SECRETS = /* @__PURE__ */ new Set([
-  "TREESEED_TURNSTILE_SECRET_KEY"
-]);
-const MANAGED_HOST_FORBIDDEN_VARIABLE_PREFIXES = [
-  "CLOUDFLARE_",
-  "RAILWAY_",
-  "TREESEED_API_",
-  "TREESEED_AUTH_",
-  "TREESEED_CLOUDFLARE_",
-  "TREESEED_RAILWAY_",
-  "TREESEED_SMTP_",
-  "TREESEED_TURNSTILE_",
-  "TREESEED_WEB_"
-];
-function allowsManagedHostDirectCiSecrets(env = process.env) {
-  const value = env[MANAGED_HOST_DIRECT_CI_OPT_IN_ENV];
-  return value === "1" || value === "true" || value === "yes";
-}
-function isTreeseedManagedHostedProject(deployConfig) {
-  return deployConfig?.hosting?.kind === "hosted_project" && deployConfig?.hub?.mode === "treeseed_hosted" && deployConfig?.runtime?.mode === "treeseed_managed";
-}
-function usesManagedHostOperationRequests(deployConfig, env = process.env) {
-  return isTreeseedManagedHostedProject(deployConfig) && !allowsManagedHostDirectCiSecrets(env);
-}
-function filterManagedHostGitHubEnvironment(required) {
-  return {
-    secrets: required.secrets.filter((name) => SAFE_MANAGED_HOST_CI_SECRETS.has(name)),
-    variables: required.variables.filter((name) => {
-      if (SAFE_MANAGED_HOST_CI_VARIABLES.has(name)) {
-        return true;
-      }
-      return !MANAGED_HOST_FORBIDDEN_VARIABLE_PREFIXES.some((prefix) => name.startsWith(prefix));
-    })
-  };
-}
-function shouldExposeManagedHostRuntimeSecret(deployConfig, _secretName, env = process.env) {
-  return !usesManagedHostOperationRequests(deployConfig, env);
-}
-export {
-  MANAGED_HOST_DIRECT_CI_OPT_IN_ENV,
-  allowsManagedHostDirectCiSecrets,
-  filterManagedHostGitHubEnvironment,
-  isTreeseedManagedHostedProject,
-  shouldExposeManagedHostRuntimeSecret,
-  usesManagedHostOperationRequests
-};

package/dist/operations/services/managed-repositories.d.ts

@@ -1,37 +0,0 @@
-export type TreeseedManagedRepositoryKind = 'root' | 'package' | 'template' | 'fixture' | 'project';
-export type TreeseedTemplateRepositoryManifest = {
-    id: string;
-    name: string;
-    category: string;
-    repository: string | null;
-    version: string | null;
-    versionSource: string;
-    manifestPath: string | null;
-    verify: {
-        fast: string | null;
-        local: string | null;
-        release: string | null;
-    };
-    release: {
-        tagPrefix: string;
-        recordPath: string;
-    };
-};
-export type TreeseedManagedRepository = {
-    id: string;
-    name: string;
-    kind: TreeseedManagedRepositoryKind;
-    dir: string;
-    relativeDir: string;
-    branchName: string | null;
-    dirty: boolean;
-    detached: boolean;
-    hasOriginRemote: boolean;
-    remoteUrl: string | null;
-    templateManifest: TreeseedTemplateRepositoryManifest | null;
-};
-export declare function parseGitmodulesPaths(root: string): string[];
-export declare function readTreeseedTemplateRepositoryManifest(repoDir: string): TreeseedTemplateRepositoryManifest | null;
-export declare function discoverTreeseedManagedRepositories(root: string): TreeseedManagedRepository[];
-export declare function checkedOutManagedWorkflowRepos(root: string): TreeseedManagedRepository[];
-export declare function checkedOutTemplateRepositories(root: string): TreeseedManagedRepository[];

package/dist/operations/services/managed-repositories.js

@@ -1,177 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { basename, relative, resolve } from "node:path";
-import { parse as parseYaml } from "yaml";
-import { currentBranch, gitStatusPorcelain, originRemoteUrl, repoRoot } from "./workspace-save.js";
-import { hasCompleteTreeseedPackageCheckout, sortWorkspacePackages, workspacePackages } from "./workspace-tools.js";
-import { discoverTreeseedPackageAdapters } from "./package-adapters.js";
-function readJsonFile(filePath) {
-  try {
-    return JSON.parse(readFileSync(filePath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function readStructuredFile(filePath) {
-  try {
-    const source = readFileSync(filePath, "utf8");
-    return filePath.endsWith(".yaml") || filePath.endsWith(".yml") ? parseYaml(source) : JSON.parse(source);
-  } catch {
-    return null;
-  }
-}
-function stringValue(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-function parseGitmodulesPaths(root) {
-  const gitmodulesPath = resolve(root, ".gitmodules");
-  if (!existsSync(gitmodulesPath)) return [];
-  const source = readFileSync(gitmodulesPath, "utf8");
-  return [...source.matchAll(/^\s*path\s*=\s*(.+?)\s*$/gmu)].map((match) => match[1].replaceAll("\\", "/").trim()).filter(Boolean);
-}
-function isIndependentGitRepo(repoDir) {
-  try {
-    return resolve(repoRoot(repoDir)) === resolve(repoDir);
-  } catch {
-    return false;
-  }
-}
-function branchName(repoDir) {
-  return currentBranch(repoDir) || null;
-}
-function hasOriginRemote(repoDir) {
-  try {
-    originRemoteUrl(repoDir);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function remoteUrl(repoDir) {
-  try {
-    return originRemoteUrl(repoDir);
-  } catch {
-    return null;
-  }
-}
-function templateManifestPath(repoDir) {
-  for (const name of ["treeseed.template.yaml", "treeseed.template.yml", "treeseed.template.json"]) {
-    const candidate = resolve(repoDir, name);
-    if (existsSync(candidate)) return candidate;
-  }
-  return null;
-}
-function defaultTemplateConfigPath(repoDir) {
-  const candidate = resolve(repoDir, "template.config.json");
-  return existsSync(candidate) ? candidate : null;
-}
-function templateVersion(repoDir, manifest, config) {
-  const versionSource = stringValue(manifest?.versionSource) ?? "template.config.json";
-  const configured = stringValue(manifest?.version) ?? stringValue(config?.templateVersion);
-  if (configured) return { version: configured, versionSource };
-  const sourcePath = resolve(repoDir, versionSource);
-  const source = readJsonFile(sourcePath);
-  return {
-    version: stringValue(source?.templateVersion) ?? stringValue(source?.version),
-    versionSource
-  };
-}
-function readTreeseedTemplateRepositoryManifest(repoDir) {
-  const manifestPath = templateManifestPath(repoDir);
-  const configPath = defaultTemplateConfigPath(repoDir);
-  const manifest = manifestPath ? readStructuredFile(manifestPath) : null;
-  const config = configPath ? readStructuredFile(configPath) : null;
-  if (!manifest && !config) return null;
-  const id = stringValue(manifest?.id) ?? stringValue(config?.id) ?? basename(repoDir);
-  const release = manifest?.release && typeof manifest.release === "object" && !Array.isArray(manifest.release) ? manifest.release : {};
-  const verify = manifest?.verify && typeof manifest.verify === "object" && !Array.isArray(manifest.verify) ? manifest.verify : {};
-  const version = templateVersion(repoDir, manifest, config);
-  return {
-    id,
-    name: stringValue(manifest?.name) ?? stringValue(config?.displayName) ?? id,
-    category: stringValue(manifest?.category) ?? stringValue(config?.category) ?? "starter",
-    repository: stringValue(manifest?.repository) ?? remoteUrl(repoDir),
-    version: version.version,
-    versionSource: version.versionSource,
-    manifestPath: manifestPath ?? configPath,
-    verify: {
-      fast: stringValue(verify.fast),
-      local: stringValue(verify.local) ?? stringValue(config?.testing?.buildCommand),
-      release: stringValue(verify.release) ?? stringValue(verify.local) ?? stringValue(config?.testing?.buildCommand)
-    },
-    release: {
-      tagPrefix: stringValue(release.tagPrefix) ?? "template/",
-      recordPath: stringValue(release.recordPath) ?? `.treeseed/templates/${id}/latest-release.json`
-    }
-  };
-}
-function classifyManagedRepo(root, relativeDir, repoDir) {
-  if (relativeDir === ".") return "root";
-  if (/^starters\/[^/]+$/u.test(relativeDir) || readTreeseedTemplateRepositoryManifest(repoDir)) return "template";
-  if (/(^|\/)\.fixtures\/treeseed-fixtures$/u.test(relativeDir)) return "fixture";
-  if (/^packages\/[^/]+$/u.test(relativeDir)) return "package";
-  return "project";
-}
-function addRecursiveSubmodules(root, relativeDir, repoDir, repos) {
-  for (const submodulePath of parseGitmodulesPaths(repoDir)) {
-    const childDir = resolve(repoDir, submodulePath);
-    const childRelativeDir = relative(root, childDir).replaceAll("\\", "/") || ".";
-    if (!existsSync(childDir) || !isIndependentGitRepo(childDir)) continue;
-    if (!repos.has(childRelativeDir)) {
-      repos.set(childRelativeDir, childDir);
-    }
-    addRecursiveSubmodules(root, childRelativeDir, childDir, repos);
-  }
-}
-function discoverTreeseedManagedRepositories(root) {
-  const gitRoot = repoRoot(root);
-  const repos = /* @__PURE__ */ new Map();
-  repos.set(".", gitRoot);
-  if (hasCompleteTreeseedPackageCheckout(root)) {
-    for (const pkg of workspacePackages(root).filter((pkg2) => pkg2.name?.startsWith("@treeseed/"))) {
-      if (existsSync(resolve(pkg.dir, ".git")) && isIndependentGitRepo(pkg.dir)) {
-        repos.set(pkg.relativeDir, pkg.dir);
-      }
-    }
-  }
-  for (const adapter of discoverTreeseedPackageAdapters(root)) {
-    if (existsSync(resolve(adapter.dir, ".git")) && isIndependentGitRepo(adapter.dir)) {
-      repos.set(adapter.relativeDir, adapter.dir);
-    }
-  }
-  addRecursiveSubmodules(root, ".", gitRoot, repos);
-  return [...repos.entries()].map(([relativeDir, dir]) => {
-    const kind = classifyManagedRepo(root, relativeDir, dir);
-    const templateManifest = kind === "template" ? readTreeseedTemplateRepositoryManifest(dir) : null;
-    const name = kind === "root" ? "@treeseed/market" : kind === "template" ? `template:${templateManifest?.id ?? basename(dir)}` : kind === "fixture" ? `fixture:${relativeDir}` : readJsonFile(resolve(dir, "package.json"))?.name ?? basename(dir);
-    const branch = branchName(dir);
-    return {
-      id: relativeDir,
-      name,
-      kind,
-      dir,
-      relativeDir,
-      branchName: branch,
-      dirty: gitStatusPorcelain(dir).length > 0,
-      detached: branch == null,
-      hasOriginRemote: hasOriginRemote(dir),
-      remoteUrl: remoteUrl(dir),
-      templateManifest
-    };
-  }).sort((left, right) => sortWorkspacePackages([
-    { name: left.name, dir: left.dir, relativeDir: left.relativeDir, packageJson: {} },
-    { name: right.name, dir: right.dir, relativeDir: right.relativeDir, packageJson: {} }
-  ])[0]?.name === left.name ? -1 : 1);
-}
-function checkedOutManagedWorkflowRepos(root) {
-  return discoverTreeseedManagedRepositories(root).filter((repo) => repo.kind !== "root");
-}
-function checkedOutTemplateRepositories(root) {
-  return discoverTreeseedManagedRepositories(root).filter((repo) => repo.kind === "template" && repo.templateManifest);
-}
-export {
-  checkedOutManagedWorkflowRepos,
-  checkedOutTemplateRepositories,
-  discoverTreeseedManagedRepositories,
-  parseGitmodulesPaths,
-  readTreeseedTemplateRepositoryManifest
-};

package/dist/operations/services/market-packaging.d.ts

@@ -1,59 +0,0 @@
-export interface MarketPackageManifest {
-    schemaVersion: 1;
-    kind: 'template' | 'knowledge_pack';
-    id: string;
-    title: string;
-    summary: string | null;
-    version: string;
-    generatedAt: string;
-    projectSlug: string;
-    sourceProjectRoot: string;
-    payloadRoot: string;
-    files: string[];
-    compatibility: {
-        minCliVersion: string;
-        minCoreVersion: string;
-        minSdkVersion: string;
-    };
-    sourceSelection: {
-        includedPaths: string[];
-    };
-    market: {
-        publisherId: string | null;
-        publisherName: string | null;
-        publishMetadata: Record<string, unknown>;
-    };
-}
-export interface MarketPackageBuildResult {
-    outputRoot: string;
-    payloadRoot: string;
-    manifestPath: string;
-    files: string[];
-    manifest: MarketPackageManifest;
-}
-export interface KnowledgePackImportResult {
-    manifest: MarketPackageManifest;
-    manifestPath: string;
-    payloadRoot: string;
-    importedPaths: string[];
-}
-export declare function resolveMarketPackageOutputRoot(projectRoot: string, kind: 'template' | 'knowledge_pack', slug: string): string;
-export declare function buildTemplateMarketPackage(projectRoot: string, input?: {
-    id?: string;
-    title?: string;
-    summary?: string | null;
-    outputRoot?: string | null;
-    projectSlug?: string | null;
-    market?: MarketPackageManifest['market'];
-}): MarketPackageBuildResult;
-export declare function buildKnowledgePackMarketPackage(projectRoot: string, input?: {
-    id?: string;
-    title?: string;
-    summary?: string | null;
-    outputRoot?: string | null;
-    projectSlug?: string | null;
-    includePaths?: string[];
-    market?: MarketPackageManifest['market'];
-}): MarketPackageBuildResult;
-export declare function importKnowledgePack(targetRoot: string, sourcePath: string): KnowledgePackImportResult;
-export declare function relativePackageFiles(outputRoot: string): string[];