@treeseed/core 0.1.2

package/dist/plugins/plugin.d.ts

@@ -0,0 +1,42 @@
+import type { TreeseedDeployConfig, TreeseedTenantConfig } from '../contracts';
+import type { TreeseedEnvironmentRegistryOverlay } from '../environment';
+import type { TreeseedSiteLayerDefinition } from '../site-resources';
+export type TreeseedSiteRouteContribution = {
+    pattern: string;
+    entrypoint?: string;
+    resourcePath?: string;
+};
+export type TreeseedSiteExtensionContribution = {
+    routes?: TreeseedSiteRouteContribution[];
+    starlightComponents?: Record<string, string>;
+    customCss?: string[];
+    remarkPlugins?: unknown[];
+    rehypePlugins?: unknown[];
+    envSchema?: Record<string, unknown>;
+    vitePlugins?: unknown[];
+    integrations?: unknown[];
+    routeMiddleware?: unknown[];
+};
+export type TreeseedPluginSiteContext = {
+    projectRoot: string;
+    tenantConfig: TreeseedTenantConfig;
+    siteConfig?: unknown;
+    deployConfig?: TreeseedDeployConfig;
+    pluginConfig: Record<string, unknown>;
+};
+export type TreeseedPluginEnvironmentContext = {
+    projectRoot: string;
+    tenantConfig?: TreeseedTenantConfig;
+    deployConfig?: TreeseedDeployConfig;
+    pluginConfig: Record<string, unknown>;
+};
+export interface TreeseedPlugin {
+    id?: string;
+    provides?: Record<string, any>;
+    siteProviders?: Record<string, TreeseedSiteExtensionContribution | ((context: TreeseedPluginSiteContext) => TreeseedSiteExtensionContribution)>;
+    siteHooks?: TreeseedSiteExtensionContribution | ((context: TreeseedPluginSiteContext) => TreeseedSiteExtensionContribution);
+    siteLayers?: TreeseedSiteLayerDefinition[] | ((context: TreeseedPluginSiteContext) => TreeseedSiteLayerDefinition[] | undefined);
+    environmentRegistry?: TreeseedEnvironmentRegistryOverlay | ((context: TreeseedPluginEnvironmentContext) => TreeseedEnvironmentRegistryOverlay | undefined);
+    [key: string]: unknown;
+}
+export declare function defineTreeseedPlugin<T extends TreeseedPlugin>(plugin: T): T;

package/dist/plugins/plugin.js

@@ -0,0 +1,6 @@
+function defineTreeseedPlugin(plugin) {
+  return plugin;
+}
+export {
+  defineTreeseedPlugin
+};

package/dist/plugins/runtime.d.ts

@@ -0,0 +1,31 @@
+import type { TreeseedDeployConfig } from '../contracts';
+type LoadedPluginEntry = {
+    package: string;
+    config: Record<string, unknown>;
+    baseDir: string;
+    plugin: Record<string, any>;
+};
+export type LoadedTreeseedPluginEntry = LoadedPluginEntry;
+export declare function loadTreeseedPlugins(config?: TreeseedDeployConfig): LoadedPluginEntry[];
+export declare function loadTreeseedPluginRuntime(config?: TreeseedDeployConfig): {
+    config: TreeseedDeployConfig;
+    plugins: LoadedPluginEntry[];
+    provided: {
+        forms: Set<string>;
+        agents: {
+            execution: Set<string>;
+            mutation: Set<string>;
+            repository: Set<string>;
+            verification: Set<string>;
+            notification: Set<string>;
+            research: Set<string>;
+            handlers: Set<string>;
+        };
+        deploy: Set<string>;
+        content: {
+            docs: Set<string>;
+        };
+        site: Set<string>;
+    };
+};
+export {};

package/dist/plugins/runtime.js

@@ -0,0 +1,120 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadTreeseedDeployConfig } from "../deploy/config.js";
+import { TREESEED_DEFAULT_PLUGIN_PACKAGE } from "./constants.js";
+import builtinDefaultPlugin from "./builtin/default-plugin.js";
+const require2 = createRequire(import.meta.url);
+function normalizeLoadedPlugin(moduleExports, packageName) {
+  const plugin = moduleExports?.default ?? moduleExports;
+  if (!plugin || typeof plugin !== "object") {
+    throw new Error(`Treeseed plugin "${packageName}" did not export a plugin object.`);
+  }
+  return plugin;
+}
+function isPathLikePluginReference(packageName) {
+  return packageName.startsWith(".") || packageName.startsWith("/") || packageName.startsWith("file:");
+}
+function loadPluginModule(packageName, tenantRoot) {
+  if (packageName === TREESEED_DEFAULT_PLUGIN_PACKAGE) {
+    return {
+      moduleExports: builtinDefaultPlugin,
+      baseDir: fileURLToPath(new URL("..", import.meta.url))
+    };
+  }
+  if (isPathLikePluginReference(packageName)) {
+    const resolvedPath2 = packageName.startsWith("file:") ? fileURLToPath(packageName) : path.resolve(tenantRoot, packageName);
+    return {
+      moduleExports: require2(resolvedPath2),
+      baseDir: path.dirname(resolvedPath2)
+    };
+  }
+  const resolvedPath = require2.resolve(packageName);
+  return {
+    moduleExports: require2(resolvedPath),
+    baseDir: path.dirname(resolvedPath)
+  };
+}
+function loadTreeseedPlugins(config = loadTreeseedDeployConfig()) {
+  const tenantRoot = config.__tenantRoot ?? process.cwd();
+  const plugins = [];
+  for (const pluginRef of config.plugins ?? []) {
+    if (pluginRef?.enabled === false) {
+      continue;
+    }
+    const loaded = loadPluginModule(pluginRef.package, tenantRoot);
+    const plugin = normalizeLoadedPlugin(loaded.moduleExports, pluginRef.package);
+    plugins.push({
+      package: pluginRef.package,
+      config: pluginRef.config ?? {},
+      baseDir: loaded.baseDir,
+      plugin
+    });
+  }
+  return plugins;
+}
+function collectProvidedIds(plugins) {
+  const provided = {
+    forms: /* @__PURE__ */ new Set(),
+    agents: {
+      execution: /* @__PURE__ */ new Set(),
+      mutation: /* @__PURE__ */ new Set(),
+      repository: /* @__PURE__ */ new Set(),
+      verification: /* @__PURE__ */ new Set(),
+      notification: /* @__PURE__ */ new Set(),
+      research: /* @__PURE__ */ new Set(),
+      handlers: /* @__PURE__ */ new Set()
+    },
+    deploy: /* @__PURE__ */ new Set(),
+    content: {
+      docs: /* @__PURE__ */ new Set()
+    },
+    site: /* @__PURE__ */ new Set()
+  };
+  for (const { plugin } of plugins) {
+    for (const id of plugin.provides?.forms ?? []) provided.forms.add(id);
+    for (const id of plugin.provides?.agents?.execution ?? []) provided.agents.execution.add(id);
+    for (const id of plugin.provides?.agents?.mutation ?? []) provided.agents.mutation.add(id);
+    for (const id of plugin.provides?.agents?.repository ?? []) provided.agents.repository.add(id);
+    for (const id of plugin.provides?.agents?.verification ?? []) provided.agents.verification.add(id);
+    for (const id of plugin.provides?.agents?.notification ?? []) provided.agents.notification.add(id);
+    for (const id of plugin.provides?.agents?.research ?? []) provided.agents.research.add(id);
+    for (const id of plugin.provides?.agents?.handlers ?? []) provided.agents.handlers.add(id);
+    for (const id of plugin.provides?.deploy ?? []) provided.deploy.add(id);
+    for (const id of plugin.provides?.content?.docs ?? []) provided.content.docs.add(id);
+    for (const id of plugin.provides?.site ?? []) provided.site.add(id);
+  }
+  return provided;
+}
+function assertSelectedProvider(provided, label, id) {
+  if (!id) {
+    throw new Error(`Treeseed plugin runtime is missing selected provider id for ${label}.`);
+  }
+  if (!provided.has(id)) {
+    throw new Error(`Treeseed plugin runtime could not resolve ${label} provider "${id}".`);
+  }
+}
+function loadTreeseedPluginRuntime(config = loadTreeseedDeployConfig()) {
+  const plugins = loadTreeseedPlugins(config);
+  const provided = collectProvidedIds(plugins);
+  const providers = config.providers;
+  assertSelectedProvider(provided.forms, "forms", providers.forms);
+  assertSelectedProvider(provided.agents.execution, "agents.execution", providers.agents.execution);
+  assertSelectedProvider(provided.agents.mutation, "agents.mutation", providers.agents.mutation);
+  assertSelectedProvider(provided.agents.repository, "agents.repository", providers.agents.repository);
+  assertSelectedProvider(provided.agents.verification, "agents.verification", providers.agents.verification);
+  assertSelectedProvider(provided.agents.notification, "agents.notification", providers.agents.notification);
+  assertSelectedProvider(provided.agents.research, "agents.research", providers.agents.research);
+  assertSelectedProvider(provided.deploy, "deploy", providers.deploy);
+  assertSelectedProvider(provided.content.docs, "content.docs", providers.content?.docs);
+  assertSelectedProvider(provided.site, "site", providers.site);
+  return {
+    config,
+    plugins,
+    provided
+  };
+}
+export {
+  loadTreeseedPluginRuntime,
+  loadTreeseedPlugins
+};

package/dist/scripts/aggregate-book.js

@@ -0,0 +1,112 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { BOOKS, TREESEED_LIBRARY_DOWNLOAD } from '../utils/books-data.js';
+import { PROJECT_TENANT } from '../tenant/bridge.js';
+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}`);
+    }
+    return path.join(PROJECT_TENANT.content.docs, relativeKnowledgePath);
+}
+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 TreeSeed 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 TreeSeed 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 TreeSeed 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();

package/dist/scripts/assert-release-tag-version.js

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packageRoot = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const packageJsonPath = resolve(packageRoot, 'package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+const packageVersion = packageJson.version;
+const legacyPrefix = 'treeseed-core-v';
+const tagName = process.argv[2] || process.env.GITHUB_REF_NAME;
+if (!tagName) {
+    console.error('Release tag validation requires a tag name argument or GITHUB_REF_NAME.');
+    process.exit(1);
+}
+const taggedVersion = tagName.startsWith(legacyPrefix)
+    ? tagName.slice(legacyPrefix.length)
+    : tagName;
+if (taggedVersion !== packageVersion) {
+    console.error(`Release tag version "${taggedVersion}" does not match @treeseed/core version "${packageVersion}".`);
+    process.exit(1);
+}
+console.log(`Release tag "${tagName}" matches @treeseed/core version "${packageVersion}".`);