@treeseed/sdk 0.4.6 → 0.4.8

package/dist/platform/environment.js

@@ -21,6 +21,7 @@ const TREESEED_ENVIRONMENT_TARGETS = [
 ];
 const TREESEED_ENVIRONMENT_PURPOSES = ["dev", "save", "deploy", "destroy", "config"];
 const TREESEED_ENVIRONMENT_SENSITIVITY = ["secret", "plain", "derived"];
+const TREESEED_ENVIRONMENT_STORAGE = ["scoped", "shared"];
 const moduleDir = dirname(fileURLToPath(import.meta.url));
 const CORE_ENVIRONMENT_PATH = resolve(moduleDir, "env.yaml");
 const TENANT_ENVIRONMENT_OVERLAY_PATH = "src/env.yaml";
@@ -45,9 +46,69 @@ function railwayManagedEnabled(context) {
 function generatedSecret(bytes = 24) {
   return randomBytes(bytes).toString("hex");
 }
+function normalizeUrl(value) {
+  return value.trim().replace(/\/$/u, "");
+}
+function primaryHostFromUrl(value) {
+  if (!value || value.trim().length === 0) {
+    return void 0;
+  }
+  try {
+    return new URL(value).host;
+  } catch {
+    return void 0;
+  }
+}
+function parseDomainList(value) {
+  return String(value ?? "").split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function deriveApiDomainFromProjectDomain(domain) {
+  if (!domain) {
+    return void 0;
+  }
+  if (domain.startsWith("api.")) {
+    return domain;
+  }
+  const segments = domain.split(".").filter(Boolean);
+  if (segments.length <= 2) {
+    return `api.${domain}`;
+  }
+  return `api.${segments.slice(1).join(".")}`;
+}
+function resolveConfiguredApiBaseUrl(context, scope, values = {}) {
+  const localBaseUrl = context.deployConfig.services?.api?.environments?.local?.baseUrl ?? context.deployConfig.surfaces?.api?.localBaseUrl ?? "http://127.0.0.1:3000";
+  if (scope === "local") {
+    return normalizeUrl(localBaseUrl);
+  }
+  const scopedBaseUrl = context.deployConfig.services?.api?.environments?.[scope]?.baseUrl ?? context.deployConfig.services?.api?.publicBaseUrl ?? context.deployConfig.surfaces?.api?.publicBaseUrl;
+  if (scopedBaseUrl) {
+    return normalizeUrl(scopedBaseUrl);
+  }
+  const projectDomains = [
+    ...parseDomainList(values.TREESEED_PROJECT_DOMAINS),
+    primaryHostFromUrl(context.deployConfig.siteUrl)
+  ].filter(Boolean);
+  for (const domain of projectDomains) {
+    const apiDomain = deriveApiDomainFromProjectDomain(domain);
+    if (apiDomain) {
+      return `https://${apiDomain}`;
+    }
+  }
+  return void 0;
+}
+function resolveWebServiceId(_values = {}) {
+  return "web";
+}
+function resolveApiWebServiceId(values = {}) {
+  return values.TREESEED_WEB_SERVICE_ID?.trim() || "web";
+}
 const VALUE_RESOLVERS = {
   generatedSecret: () => generatedSecret(),
-  localFormsBypassDefault: () => "true"
+  localFormsBypassDefault: () => "true",
+  projectDomainsDefault: (context) => primaryHostFromUrl(context.deployConfig.siteUrl),
+  apiBaseUrlDefault: (context, scope, values) => resolveConfiguredApiBaseUrl(context, scope, values),
+  webServiceIdDefault: (_context, _scope, values) => resolveWebServiceId(values),
+  apiWebServiceIdDefault: (_context, _scope, values) => resolveApiWebServiceId(values)
 };
 const PREDICATES = {
   turnstileEnabled: (context) => turnstileEnabled(context),
@@ -135,6 +196,7 @@ function materializeEntry(id, entry) {
   return {
     ...entry,
     id,
+    storage: entry.storage ?? "scoped",
     defaultValue: resolveNamedValueResolver(entry.defaultValueRef),
     localDefaultValue: resolveNamedValueResolver(entry.localDefaultValueRef),
     isRelevant: resolveNamedPredicate(entry.relevanceRef),
@@ -233,18 +295,30 @@ function isEntryRequired(entry, context, scope, purpose) {
   }
   return false;
 }
-function materializeDefaultValue(entry, context, scope) {
+function materializeDefaultValue(entry, context, scope, values = {}) {
   const source = scope === "local" && entry.localDefaultValue !== void 0 ? entry.localDefaultValue : entry.defaultValue;
   if (source === void 0) {
     return void 0;
   }
-  return typeof source === "function" ? source(context, scope) : source;
+  return typeof source === "function" ? source(context, scope, values) : source;
 }
 function getTreeseedEnvironmentSuggestedValues(options) {
   const registry = resolveTreeseedEnvironmentRegistry(options);
-  return Object.fromEntries(
-    registry.entries.filter((entry) => isTreeseedEnvironmentEntryRelevant(entry, registry.context, options.scope, options.purpose)).map((entry) => [entry.id, materializeDefaultValue(entry, registry.context, options.scope)]).filter(([, value]) => value !== void 0)
-  );
+  const suggestedValues = {};
+  const seedValues = { ...options.values ?? {} };
+  for (const entry of registry.entries.filter(
+    (candidate) => isTreeseedEnvironmentEntryRelevant(candidate, registry.context, options.scope, options.purpose)
+  )) {
+    const value = materializeDefaultValue(entry, registry.context, options.scope, { ...suggestedValues, ...seedValues });
+    if (value === void 0) {
+      continue;
+    }
+    suggestedValues[entry.id] = value;
+  }
+  return suggestedValues;
+}
+function isTreeseedEnvironmentEntryRequired(entry, context, scope, purpose) {
+  return isEntryRequired(entry, context, scope, purpose);
 }
 function valuePresent(value) {
   return typeof value === "string" && value.trim().length > 0;
@@ -322,9 +396,11 @@ export {
   TREESEED_ENVIRONMENT_REQUIREMENTS,
   TREESEED_ENVIRONMENT_SCOPES,
   TREESEED_ENVIRONMENT_SENSITIVITY,
+  TREESEED_ENVIRONMENT_STORAGE,
   TREESEED_ENVIRONMENT_TARGETS,
   getTreeseedEnvironmentSuggestedValues,
   isTreeseedEnvironmentEntryRelevant,
+  isTreeseedEnvironmentEntryRequired,
   loadTreeseedEnvironmentOverlay,
   resolveTreeseedEnvironmentContext,
   resolveTreeseedEnvironmentRegistry,

package/dist/scripts/aggregate-book.js

@@ -1,121 +1,16 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { buildTenantBookRuntime } from '../platform/books-data.js';
-import { loadTreeseedManifest } from '../platform/tenant-config.js';
-const PROJECT_TENANT = loadTreeseedManifest();
-const { BOOKS, TREESEED_LIBRARY_DOWNLOAD } = buildTenantBookRuntime(PROJECT_TENANT, {
-    projectRoot: PROJECT_TENANT.__tenantRoot ?? process.cwd(),
-    docsLibraryDownload: {
-        downloadFileName: 'karyon-knowledge.md',
-        downloadHref: '/books/karyon-knowledge.md',
-        downloadTitle: 'Karyon Knowledge Library',
-    },
-});
-const projectRoot = PROJECT_TENANT.__tenantRoot ?? process.cwd();
-const outputDir = path.join(projectRoot, 'public', 'books');
-const legacyOutputFile = path.join(projectRoot, 'public', 'book.md');
-function sortPaths(paths) {
-    return [...paths].sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }));
-}
-function getSidebarOrder(filePath) {
-    const rawContent = fs.readFileSync(filePath, 'utf8');
-    const frontmatterMatch = rawContent.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    if (!frontmatterMatch)
-        return Number.POSITIVE_INFINITY;
-    const orderMatch = frontmatterMatch[1].match(/^\s{2}order:\s*(\d+)\s*$/m);
-    return orderMatch ? Number.parseInt(orderMatch[1], 10) : Number.POSITIVE_INFINITY;
-}
-function collectMarkdownFiles(rootPath) {
-    if (!fs.existsSync(rootPath)) {
-        throw new Error(`Book export root not found: ${rootPath}`);
-    }
-    const stats = fs.statSync(rootPath);
-    if (stats.isFile()) {
-        return [rootPath];
-    }
-    const entries = fs.readdirSync(rootPath, { withFileTypes: true });
-    return sortPaths(entries.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 stripFrontmatter(content) {
-    return content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '').trim();
-}
-function stripMdxOnlySyntax(content) {
-    return content
-        .replace(/^import\s.+$/gm, '')
-        .replace(/^\s*<\/?[A-Z][^>]*>\s*$/gm, '')
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
-}
-function inferExportRootFromBasePath(book) {
-    const normalizedBasePath = String(book.basePath || '').trim();
-    const knowledgePrefix = '/knowledge/';
-    if (!normalizedBasePath.startsWith(knowledgePrefix)) {
-        throw new Error(`Book basePath must start with "${knowledgePrefix}" to infer exports: ${book.basePath}`);
-    }
-    const relativeKnowledgePath = normalizedBasePath
-        .slice(knowledgePrefix.length)
-        .replace(/^\/+|\/+$/g, '');
-    if (!relativeKnowledgePath) {
-        throw new Error(`Book basePath must identify a knowledge directory: ${book.basePath}`);
+import { exportTenantBookPackages } from '../platform/book-export.js';
+async function main() {
+    console.log('Generating Treeseed AI book packages...');
+    const result = await exportTenantBookPackages({ projectRoot: process.cwd() });
+    for (const entry of result.bookPackages) {
+        console.log(`Generated ${path.relative(result.projectRoot, entry.markdownPath)}`);
+        console.log(`Generated ${path.relative(result.projectRoot, entry.indexPath)}`);
     }
-    return path.join(PROJECT_TENANT.content.docs, relativeKnowledgePath);
+    console.log(`Generated ${path.relative(result.projectRoot, result.libraryPackage.markdownPath)}`);
+    console.log(`Generated ${path.relative(result.projectRoot, result.libraryPackage.indexPath)}`);
 }
-function resolveExportRoots(book) {
-    if (Array.isArray(book.exportRoots) && book.exportRoots.length > 0) {
-        return book.exportRoots;
-    }
-    return [inferExportRootFromBasePath(book)];
-}
-function resolveBookFiles(book) {
-    const files = resolveExportRoots(book).flatMap((root) => collectMarkdownFiles(path.resolve(projectRoot, root)).sort((left, right) => {
-        const orderDelta = getSidebarOrder(left) - getSidebarOrder(right);
-        if (orderDelta !== 0)
-            return orderDelta;
-        return left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' });
-    }));
-    return Array.from(new Set(files));
-}
-function buildBookMarkdown(book) {
-    const sections = resolveBookFiles(book).map((filePath) => {
-        const rawContent = fs.readFileSync(filePath, 'utf8');
-        return stripMdxOnlySyntax(stripFrontmatter(rawContent));
-    });
-    return `# ${book.downloadTitle}\n\n> This document is auto-generated from the Karyon knowledge source.\n\n${sections.join('\n\n---\n\n')}\n`;
-}
-function ensureOutputDir() {
-    fs.mkdirSync(outputDir, { recursive: true });
-}
-function writeBookOutput(fileName, content) {
-    const outputPath = path.join(outputDir, fileName);
-    fs.writeFileSync(outputPath, content);
-    return outputPath;
-}
-function main() {
-    console.log('Generating contextual Karyon knowledge exports...');
-    ensureOutputDir();
-    const bookOutputs = BOOKS.map((book) => {
-        const content = buildBookMarkdown(book);
-        const outputPath = writeBookOutput(book.downloadFileName, content);
-        console.log(`Generated ${path.relative(projectRoot, outputPath)}`);
-        return { book, content };
-    });
-    const compositeContent = `# ${TREESEED_LIBRARY_DOWNLOAD.downloadTitle}\n\n> This document is auto-generated from the Karyon knowledge source.\n\n${bookOutputs
-        .map(({ content }) => content.trim())
-        .join('\n\n---\n\n')}\n`;
-    const compositeOutputPath = writeBookOutput(TREESEED_LIBRARY_DOWNLOAD.downloadFileName, compositeContent);
-    console.log(`Generated ${path.relative(projectRoot, compositeOutputPath)}`);
-    if (fs.existsSync(legacyOutputFile)) {
-        fs.rmSync(legacyOutputFile);
-        console.log(`Removed legacy export ${path.relative(projectRoot, legacyOutputFile)}`);
-    }
-}
-main();
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/scripts/config-treeseed.js

@@ -1,8 +1,5 @@
 #!/usr/bin/env node
-import readline from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import { collectCliPreflight } from '../operations/services/workspace-preflight.js';
-import { applyTreeseedEnvironmentToProcess, ensureTreeseedGitignoreEntries, getTreeseedMachineConfigPaths, rotateTreeseedMachineKey, runTreeseedConfigWizard, writeTreeseedLocalEnvironmentFiles, } from '../operations/services/config-runtime.js';
+import { applyTreeseedConfigValues, applyTreeseedSafeRepairs, collectTreeseedConfigContext, ensureTreeseedGitignoreEntries, finalizeTreeseedConfig, getTreeseedMachineConfigPaths, rotateTreeseedMachineKey, } from '../operations/services/config-runtime.js';
 const tenantRoot = process.cwd();
 function parseArgs(argv) {
     const parsed = {
@@ -45,42 +42,37 @@ const scopes = options.scopes.length === 0 || options.scopes.includes('all')
     ? ['local', 'staging', 'prod']
     : ['local', 'staging', 'prod'].filter((scope) => options.scopes.includes(scope));
 ensureTreeseedGitignoreEntries(tenantRoot);
-const preflight = collectCliPreflight({ cwd: tenantRoot, requireAuth: false });
-const rl = readline.createInterface({ input, output });
 try {
-    console.log('Treeseed configuration wizard');
-    console.log('This command writes a local machine config, generates .env.local and .dev.vars, and can sync GitHub or Cloudflare settings.');
-    console.log('Enter a value to set it, press Enter to keep the current/default value, or enter "-" to clear a value.\n');
     if (options.rotateMachineKey) {
         const result = rotateTreeseedMachineKey(tenantRoot);
         console.log('Treeseed machine key rotated.');
         console.log(`Machine key: ${result.keyPath}`);
     }
     else {
-        const result = await runTreeseedConfigWizard({
+        applyTreeseedSafeRepairs(tenantRoot);
+        const context = collectTreeseedConfigContext({
+            tenantRoot,
+            scopes,
+            env: process.env,
+        });
+        const updates = scopes.flatMap((scope) => context.entriesByScope[scope].map((entry) => ({
+            scope,
+            entryId: entry.id,
+            value: entry.effectiveValue,
+            reused: entry.currentValue.length > 0 || entry.suggestedValue.length > 0,
+        })));
+        const applyResult = applyTreeseedConfigValues({ tenantRoot, updates });
+        const result = finalizeTreeseedConfig({
             tenantRoot,
             scopes,
             sync: options.sync,
-            authStatus: preflight.checks.auth,
-            prompt: async (message) => {
-                if (!process.stdin.isTTY || !process.stdout.isTTY) {
-                    return '';
-                }
-                try {
-                    return await rl.question(message);
-                }
-                catch {
-                    return '';
-                }
-            },
+            env: process.env,
         });
-        writeTreeseedLocalEnvironmentFiles(tenantRoot);
-        applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'local', override: true });
         const { configPath, keyPath } = getTreeseedMachineConfigPaths(tenantRoot);
-        console.log('\nTreeseed config completed.');
+        console.log('Treeseed config completed.');
         console.log(`Machine config: ${configPath}`);
         console.log(`Machine key: ${keyPath}`);
-        console.log(`Updated values: ${result.updated.length}`);
+        console.log(`Updated values: ${applyResult.updated.length}`);
         console.log(`Initialized environments: ${result.initialized.length}`);
         if (result.synced.github) {
             console.log(`GitHub sync: ${result.synced.github.secrets.length} secrets, ${result.synced.github.variables.length} variables (${result.synced.github.repository})`);
@@ -91,5 +83,4 @@ try {
     }
 }
 finally {
-    rl.close();
 }

package/dist/sdk-types.d.ts

@@ -777,6 +777,7 @@ export interface SdkTemplateCatalogEntry {
     minCliVersion: string;
     minCoreVersion?: string;
     fulfillment: {
+        mode?: 'packaged' | 'git';
         source: SdkTemplateCatalogSource;
         hooksPolicy: 'builtin_only' | 'trusted_only' | 'disabled';
         supportsReconcile: boolean;

package/dist/template-catalog.js

@@ -66,6 +66,7 @@ function normalizeTemplateCatalogEntry(value) {
     minCliVersion: expectString(record.minCliVersion, "minCliVersion"),
     minCoreVersion: optionalString(record.minCoreVersion),
     fulfillment: {
+      mode: optionalString(fulfillment.mode),
       source: {
         kind: "git",
         repoUrl: expectString(source.repoUrl, "fulfillment.source.repoUrl"),