@treeseed/sdk 0.4.7 → 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/workflow/operations.d.ts

@@ -1,5 +1,6 @@
+import { checkTreeseedProviderConnections } from '../operations/services/config-runtime.ts';
 import { resolveTreeseedWorkflowState } from '../workflow-state.ts';
-import type { TreeseedCloseInput, TreeseedConfigInput, TreeseedDestroyInput, TreeseedReleaseInput, TreeseedSaveInput, TreeseedStageInput, TreeseedSwitchInput, TreeseedTaskBranchMetadata, TreeseedWorkflowContext, TreeseedWorkflowDevInput, TreeseedWorkflowNextStep, TreeseedWorkflowOperationId, TreeseedWorkflowResult } from '../workflow.ts';
+import type { TreeseedCloseInput, TreeseedConfigInput, TreeseedDestroyInput, TreeseedExportInput, TreeseedReleaseInput, TreeseedSaveInput, TreeseedStageInput, TreeseedSwitchInput, TreeseedTaskBranchMetadata, TreeseedWorkflowContext, TreeseedWorkflowDevInput, TreeseedWorkflowNextStep, TreeseedWorkflowOperationId, TreeseedWorkflowResult } from '../workflow.ts';
 type WorkflowWrite = NonNullable<TreeseedWorkflowContext['write']>;
 type WorkflowStatePayload = ReturnType<typeof resolveTreeseedWorkflowState>;
 export type TreeseedWorkflowErrorCode = 'validation_failed' | 'merge_conflict' | 'missing_runtime_auth' | 'deployment_timeout' | 'confirmation_required' | 'unsupported_transport' | 'unsupported_state';
@@ -22,10 +23,6 @@ export type WorkflowOperationHelpers = {
         tasks: TreeseedTaskBranchMetadata[];
     }>>;
 };
-type TreeseedRepairAction = {
-    id: string;
-    detail: string;
-};
 export declare function workflowStatus(helpers: WorkflowOperationHelpers): Promise<TreeseedWorkflowResult<import("../workflow-state.ts").TreeseedWorkflowState>>;
 export declare function workflowTasks(helpers: WorkflowOperationHelpers): Promise<TreeseedWorkflowResult<{
     tasks: TreeseedTaskBranchMetadata[];
@@ -36,7 +33,7 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
     sync: "all" | "cloudflare" | "railway" | "none" | "github";
     configPath: string;
     keyPath: string;
-    repairs: TreeseedRepairAction[];
+    repairs: import("../operations/services/config-runtime.ts").TreeseedRepairAction[];
     preflight: {
         ok: boolean;
         requireAuth: boolean;
@@ -71,13 +68,45 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
         actVerificationReady: any;
         remediation: string[];
     };
+    context: import("../operations/services/config-runtime.ts").TreeseedCollectedConfigContext;
     result: {
-        scopes: string[];
-        updated: never[];
-        synced: {};
-        initialized: never[];
-        connectionChecks: never[];
+        scopes: ("local" | "staging" | "prod")[];
+        synced: Record<string, unknown>;
+        initialized: Array<{
+            scope: import("../operations/services/config-runtime.ts").TreeseedConfigScope;
+            secrets: number;
+            target: string;
+        }>;
+        connectionChecks: ReturnType<typeof checkTreeseedProviderConnections>[];
+        validationByScope: Record<import("../operations/services/config-runtime.ts").TreeseedConfigScope, ReturnType<typeof import("../platform/environment.ts").validateTreeseedEnvironmentValues>>;
+        updated: {
+            scope: import("../operations/services/config-runtime.ts").TreeseedConfigScope | "shared";
+            id: string;
+            reused: boolean;
+            cleared: boolean;
+        }[];
+        envFiles: {
+            envLocalPath: string;
+            devVarsPath: string;
+        } | null;
     };
+    reports: {
+        scope: "local" | "staging" | "prod";
+        environment: {
+            scope: "local" | "staging" | "prod";
+            revealSecrets: boolean;
+            entries: any;
+        };
+        provider: {
+            scope: string;
+            ok: boolean;
+            checks: {
+                provider: any;
+                ready: any;
+                detail: any;
+            }[];
+        };
+    }[];
     state: import("../workflow-state.ts").TreeseedWorkflowState;
     readiness: {
         local: {
@@ -108,10 +137,22 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
         secretsRevealed: boolean;
         reports: {
             scope: "local" | "staging" | "prod";
-            environmentReport: string;
-            providerReport: string;
+            environment: {
+                scope: "local" | "staging" | "prod";
+                revealSecrets: boolean;
+                entries: any;
+            };
+            provider: {
+                scope: string;
+                ok: boolean;
+                checks: {
+                    provider: any;
+                    ready: any;
+                    detail: any;
+                }[];
+            };
         }[];
-        repairs: TreeseedRepairAction[];
+        repairs: import("../operations/services/config-runtime.ts").TreeseedRepairAction[];
         preflight: {
             ok: boolean;
             requireAuth: boolean;
@@ -157,7 +198,7 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
         scopes: ("local" | "staging" | "prod")[];
         sync: "all" | "cloudflare" | "railway" | "none" | "github";
         keyPath: string;
-        repairs: TreeseedRepairAction[];
+        repairs: import("../operations/services/config-runtime.ts").TreeseedRepairAction[];
         preflight: {
             ok: boolean;
             requireAuth: boolean;
@@ -197,6 +238,9 @@ export declare function workflowConfig(helpers: WorkflowOperationHelpers, input?
     };
     nextSteps: TreeseedWorkflowNextStep[];
 }>;
+export declare function workflowExport(helpers: WorkflowOperationHelpers, input?: TreeseedExportInput): Promise<TreeseedWorkflowResult<import("../operations/services/export-runtime.ts").TreeseedExportResult & {
+    finalState: WorkflowStatePayload;
+}>>;
 export declare function workflowSwitch(helpers: WorkflowOperationHelpers, input: TreeseedSwitchInput): Promise<TreeseedWorkflowResult<{
     branchName: string;
     created: boolean;