@treeseed/core 0.4.8 → 0.4.9

package/dist/scripts/aggregate-book.js

@@ -1,112 +1,17 @@
-import fs from 'node:fs';
 import path from 'node:path';
-import { BOOKS, TREESEED_LIBRARY_DOWNLOAD } from '@treeseed/sdk/platform/books-data';
+import { exportTenantBookPackages } from '@treeseed/sdk/platform/book-export';
 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)}`);
+async function main() {
+    console.log('Generating Treeseed AI book packages...');
+    const result = await exportTenantBookPackages({ projectRoot: PROJECT_TENANT.__tenantRoot ?? 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)}`);
     }
+    console.log(`Generated ${path.relative(result.projectRoot, result.libraryPackage.markdownPath)}`);
+    console.log(`Generated ${path.relative(result.projectRoot, result.libraryPackage.indexPath)}`);
 }
-main();
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/scripts/test-smoke.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
 import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
@@ -24,36 +24,92 @@ function run(command, args, cwd = packageRoot, capture = false) {
     }
     return (result.stdout ?? '').trim();
 }
-function resolveNodeModulesRoot() {
-    let lastCandidate = null;
-    let current = packageRoot;
-    while (true) {
-        const candidate = resolve(current, 'node_modules');
-        try {
-            readdirSync(candidate);
-            lastCandidate = candidate;
+function runtimeDependencyNamesFor(root) {
+    const packageJson = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8'));
+    return Object.keys(packageJson.dependencies ?? {});
+}
+function resolveWorkspaceRuntimePackageRoots() {
+    const roots = new Map();
+    for (const dependencyName of runtimeDependencyNamesFor(packageRoot)) {
+        const dependencyRoot = resolveTreeseedRuntimeDependencyRoot(dependencyName);
+        if (dependencyRoot) {
+            roots.set(dependencyName, dependencyRoot);
+        }
+    }
+    return roots;
+}
+function collectRuntimeDependenciesForPackaging() {
+    const dependencyNames = new Set(runtimeDependencyNamesFor(packageRoot));
+    const searchRoots = [
+        packageRoot,
+        sdkPackageRoot,
+    ];
+    const queue = [...resolveWorkspaceRuntimePackageRoots().values()];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const nextRoot = queue.shift();
+        if (!nextRoot || visited.has(nextRoot)) {
+            continue;
         }
-        catch {
+        visited.add(nextRoot);
+        for (const dependencyName of runtimeDependencyNamesFor(nextRoot)) {
+            dependencyNames.add(dependencyName);
+            const dependencyRoot = resolveTreeseedRuntimeDependencyRoot(dependencyName, searchRoots);
+            if (dependencyRoot) {
+                queue.push(dependencyRoot);
+            }
+        }
+    }
+    return dependencyNames;
+}
+function resolveTreeseedRuntimeDependencyRoot(packageName, searchRoots = [packageRoot, sdkPackageRoot]) {
+    if (!packageName.startsWith('@treeseed/')) {
+        return null;
+    }
+    const folderName = packageName.slice('@treeseed/'.length);
+    const workspaceCandidateRoot = resolve(packageRoot, '..', folderName);
+    if (existsSync(resolve(workspaceCandidateRoot, 'package.json'))) {
+        return workspaceCandidateRoot;
+    }
+    try {
+        return resolveInstalledPackageRoot(packageName, searchRoots);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveInstalledPackageRoot(packageName, searchRoots) {
+    let resolvedEntry = require.resolve(packageName, { paths: searchRoots });
+    let current = dirname(resolvedEntry);
+    while (true) {
+        const packageJsonPath = resolve(current, 'package.json');
+        if (existsSync(packageJsonPath)) {
+            return current;
         }
         const parent = resolve(current, '..');
-        if (parent === current)
-            break;
+        if (parent === current) {
+            throw new Error(`Unable to resolve installed package root for ${packageName}.`);
+        }
         current = parent;
     }
-    if (lastCandidate) {
-        return lastCandidate;
-    }
-    throw new Error(`Unable to locate node_modules for ${packageRoot}.`);
 }
-function mirrorDependencies(tempRoot) {
-    const sharedNodeModules = resolveNodeModulesRoot();
-    for (const entry of readdirSync(sharedNodeModules, { withFileTypes: true })) {
-        if (entry.name === '.bin' || entry.name === '@treeseed') {
+function mirrorDependencies(tempRoot, excludedPackages = new Set()) {
+    const runtimeDependencies = collectRuntimeDependenciesForPackaging();
+    const searchRoots = [
+        packageRoot,
+        ...resolveWorkspaceRuntimePackageRoots().values(),
+    ];
+    for (const packageName of runtimeDependencies) {
+        if (excludedPackages.has(packageName) || packageName === '@treeseed/core') {
+            continue;
+        }
+        const sourcePath = resolveInstalledPackageRoot(packageName, searchRoots);
+        const targetPath = resolve(tempRoot, 'node_modules', ...packageName.split('/'));
+        if (existsSync(targetPath)) {
             continue;
         }
-        const targetPath = resolve(tempRoot, 'node_modules', entry.name);
         mkdirSync(dirname(targetPath), { recursive: true });
-        symlinkSync(resolve(sharedNodeModules, entry.name), targetPath, 'dir');
+        symlinkSync(sourcePath, targetPath, 'dir');
     }
 }
 function pack(root, outputRoot, fallbackName) {
@@ -98,6 +154,7 @@ try {
     mkdirSync(packRoot, { recursive: true });
     mkdirSync(extractRoot, { recursive: true });
     const coreTarball = pack(packageRoot, packRoot, 'treeseed-core.tgz');
+    const workspaceRuntimePackageRoots = resolveWorkspaceRuntimePackageRoots();
     if (existsSync(resolve(sdkPackageRoot, 'scripts', 'run-ts.mjs'))) {
         const sdkTarball = pack(sdkPackageRoot, packRoot, 'treeseed-sdk.tgz');
         installPackagedPackage(extractRoot, installRoot, sdkTarball, 'sdk');
@@ -106,7 +163,7 @@ try {
         installPackageDirectory(installRoot, sdkPackageRoot, 'sdk');
     }
     installPackagedPackage(extractRoot, installRoot, coreTarball, 'core');
-    mirrorDependencies(installRoot);
+    mirrorDependencies(installRoot, new Set(workspaceRuntimePackageRoots.keys()));
     writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({ name: 'treeseed-core-smoke', private: true, type: 'module' }, null, 2)}\n`, 'utf8');
     run(process.execPath, [
         '--input-type=module',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/core",
-  "version": "0.4.8",
+  "version": "0.4.9",
   "description": "Treeseed integrated platform starter for Astro/Starlight web runtimes and Hono API runtimes.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -67,7 +67,7 @@
     "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
   },
   "dependencies": {
-    "@treeseed/sdk": "^0.4.7",
+    "@treeseed/sdk": "^0.4.8",
     "@astrojs/check": "^0.9.8",
     "@astrojs/cloudflare": "^12.6.13",
     "@astrojs/sitemap": "3.7.0",