@treeseed/core 0.1.2 → 0.3.0

package/dist/scripts/build-dist.js

@@ -343,7 +343,7 @@ async function main() {
             await compileModule(filePath, srcRoot, distRoot);
             continue;
         }
-        if (COPY_EXTENSIONS.has(extension) || filePath.endsWith('.d.js')) {
+        if (COPY_EXTENSIONS.has(extension)) {
             copyAsset(filePath, srcRoot, distRoot);
         }
     }
@@ -368,7 +368,11 @@ async function main() {
         writeFileSync(filePath, rewriteTreeseedStarlightSpecifiers(contents, filePath), 'utf8');
     }
     writeCompatibilityEntrypoint(resolve(distRoot, 'config.js'), "import starlight from './vendor/starlight/index.js';\nimport { createTreeseedSite } from './site.js';\nimport { loadTreeseedManifest } from './tenant/config.js';\n\nexport function createTreeseedTenantSite(manifestPath) {\n\tconst tenant = loadTreeseedManifest(manifestPath);\n\treturn createTreeseedSite(tenant, { starlight });\n}");
+    writeCompatibilityEntrypoint(resolve(distRoot, 'config.d.ts'), "export declare function createTreeseedTenantSite(manifestPath?: string): import('astro').AstroUserConfig<never, never, never>;");
     writeCompatibilityEntrypoint(resolve(distRoot, 'content-config.js'), "import { docsLoader } from './vendor/starlight/loaders.js';\nimport { docsSchema } from './vendor/starlight/schema.js';\nimport { createTreeseedCollections } from './content.js';\nimport { loadTreeseedManifest } from './tenant/config.js';\n\nexport function createTreeseedTenantCollections(manifestPath) {\n\tconst tenant = loadTreeseedManifest(manifestPath);\n\treturn createTreeseedCollections(tenant, { docsLoader, docsSchema });\n}");
+    writeCompatibilityEntrypoint(resolve(distRoot, 'content-config.d.ts'), "export declare function createTreeseedTenantCollections(manifestPath?: string): {\n\tpages: any;\n\tnotes: any;\n\tquestions: any;\n\tobjectives: any;\n\tpeople: any;\n\tagents: any;\n\tbooks: any;\n\tdocs: any;\n};");
+    rmSync(resolve(distRoot, 'config.d.js'), { force: true });
+    rmSync(resolve(distRoot, 'content-config.d.js'), { force: true });
     writeCompatibilityEntrypoint(resolve(vendoredStarlightRoot, 'utils', 'routing.js'), "export * from './routing/index.js';");
     copyAsset(resolve(packageRoot, 'tsconfigs/strict.json'), packageRoot, distRoot);
     copyPackageAsset('@astrojs/mdx', 'template/content-module-types.d.ts', 'template/content-module-types.d.ts');

package/dist/scripts/release-verify.js

@@ -43,8 +43,7 @@ function scanDirectory(root) {
         }
     }
 }
-run('npm', ['run', 'fixtures:check']);
-run('npm', ['run', 'build:dist']);
+run('npm', ['run', 'lint']);
 scanDirectory(resolve(packageRoot, 'dist'));
 run('npm', ['run', 'test:unit']);
 run('npm', ['run', 'check']);

package/dist/scripts/test-smoke.js

@@ -7,12 +7,17 @@ import { createRequire } from 'node:module';
 import { packageRoot } from './package-tools.js';
 const require = createRequire(import.meta.url);
 const sdkPackageRoot = resolve(dirname(require.resolve('@treeseed/sdk')), '..');
+const npmCacheDir = resolve(tmpdir(), 'treeseed-npm-cache');
 function run(command, args, cwd = packageRoot, capture = false) {
     const result = spawnSync(command, args, {
         cwd,
         stdio: capture ? 'pipe' : 'inherit',
         encoding: 'utf8',
-        env: process.env,
+        env: {
+            ...process.env,
+            npm_config_cache: npmCacheDir,
+            NPM_CONFIG_CACHE: npmCacheDir,
+        },
     });
     if (result.status !== 0) {
         throw new Error(result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`);
@@ -61,12 +66,18 @@ function pack(root, outputRoot, fallbackName) {
         return bundledTarball;
     }
     mkdirSync(outputRoot, { recursive: true });
-    const output = run('npm', ['pack', '--silent', '--ignore-scripts', '--pack-destination', outputRoot], root, true);
+    const output = run('npm', ['pack', '--ignore-scripts', '--cache', npmCacheDir, '--pack-destination', outputRoot], root, true);
     const filename = output
         .split('\n')
         .map((line) => line.trim())
         .filter(Boolean)
-        .at(-1) ?? fallbackName;
+        .at(-1)
+        ?? readdirSync(outputRoot, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.tgz'))
+            .map((entry) => entry.name)
+            .sort((left, right) => left.localeCompare(right, undefined, { numeric: true, sensitivity: 'base' }))
+            .at(-1)
+        ?? fallbackName;
     return resolve(outputRoot, filename);
 }
 function installPackageDirectory(tempRoot, packageRoot, folderName) {

package/dist/scripts/workspace-bootstrap.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { packageRoot } from './package-tools.js';
+const require = createRequire(import.meta.url);
+const requiredPackages = [
+    { name: '@treeseed/sdk', dir: 'packages/sdk', build: true },
+    { name: '@treeseed/core', dir: 'packages/core', build: true },
+    { name: '@treeseed/agent', dir: 'packages/agent', build: true },
+    { name: '@treeseed/api', dir: 'packages/api', build: true },
+    { name: '@treeseed/cli', dir: 'packages/cli', build: true, binName: 'treeseed' },
+];
+function packageState(root, entry) {
+    const dir = resolve(root, entry.dir);
+    const packageJsonPath = resolve(dir, 'package.json');
+    return {
+        ...entry,
+        dir,
+        relativeDir: entry.dir,
+        packageJsonPath,
+        present: existsSync(dir) && existsSync(packageJsonPath),
+        dirExists: existsSync(dir),
+    };
+}
+export function detectTreeseedBootstrapMode(startRoot = process.cwd()) {
+    const root = resolve(startRoot);
+    const forcedMode = process.env.TREESEED_BOOTSTRAP_MODE;
+    if (forcedMode === 'workspace' || forcedMode === 'registry') {
+        const packages = requiredPackages.map((entry) => packageState(root, entry));
+        return {
+            mode: forcedMode,
+            packages,
+            missing: packages.filter((entry) => !entry.present),
+        };
+    }
+    const packages = requiredPackages.map((entry) => packageState(root, entry));
+    const present = packages.filter((entry) => entry.present);
+    const partial = present.length > 0 && present.length < packages.length;
+    if (partial) {
+        return {
+            mode: 'partial',
+            packages,
+            missing: packages.filter((entry) => !entry.present),
+        };
+    }
+    return {
+        mode: present.length === packages.length ? 'workspace' : 'registry',
+        packages,
+        missing: packages.filter((entry) => !entry.present),
+    };
+}
+function run(command, args, options = {}) {
+    const result = spawnSync(command, args, {
+        cwd: options.cwd,
+        env: { ...process.env, ...(options.env ?? {}) },
+        stdio: 'inherit',
+        encoding: 'utf8',
+    });
+    if (result.status !== 0) {
+        const rendered = [command, ...args].join(' ');
+        throw new Error(`Command failed: ${rendered}`);
+    }
+}
+function resolvePackageBinary(packageName, binName = packageName, root = process.cwd()) {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`, { paths: [root, packageRoot] });
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    const binField = packageJson.bin;
+    const relativePath = typeof binField === 'string' ? binField : binField?.[binName];
+    if (!relativePath) {
+        throw new Error(`Unable to resolve binary "${binName}" from package "${packageName}".`);
+    }
+    return resolve(dirname(packageJsonPath), relativePath);
+}
+function runStarlightPatchFromRegistry(root) {
+    const corePackageJsonPath = require.resolve('@treeseed/core/package.json', { paths: [root, packageRoot] });
+    const coreRoot = dirname(corePackageJsonPath);
+    const patchScriptPath = resolve(coreRoot, 'dist', 'scripts', 'patch-starlight-content-path.js');
+    if (existsSync(patchScriptPath)) {
+        run(process.execPath, [patchScriptPath], { cwd: root });
+        return;
+    }
+    const treeseedBin = resolvePackageBinary('@treeseed/cli', 'treeseed', root);
+    run(process.execPath, [treeseedBin, 'starlight:patch'], { cwd: root });
+}
+function runStarlightPatchFromWorkspace(root, packages) {
+    const corePackage = packages.find((entry) => entry.name === '@treeseed/core');
+    run(process.execPath, [resolve(corePackage.dir, 'scripts/run-ts.mjs'), resolve(corePackage.dir, 'scripts/patch-starlight-content-path.ts')], { cwd: root });
+}
+function linkWorkspacePackages(root, packages) {
+    for (const targetRoot of [root, ...packages.map((entry) => entry.dir)]) {
+        const scopeRoot = resolve(targetRoot, 'node_modules/@treeseed');
+        mkdirSync(scopeRoot, { recursive: true });
+        for (const entry of packages) {
+            const linkPath = resolve(scopeRoot, entry.name.replace('@treeseed/', ''));
+            if (resolve(linkPath) === resolve(entry.dir)) {
+                continue;
+            }
+            rmSync(linkPath, { recursive: true, force: true });
+            symlinkSync(entry.dir, linkPath, 'dir');
+        }
+    }
+}
+function printPartialError(state) {
+    const missing = state.missing.map((entry) => `  - ${entry.relativeDir}`).join('\n');
+    console.error('Treeseed bootstrap found a partial package checkout.');
+    console.error('');
+    console.error('Either initialize all Treeseed package submodules:');
+    console.error('  git submodule update --init --recursive');
+    console.error('');
+    console.error('Or remove the partial package checkout and use registry mode.');
+    console.error('');
+    console.error(`Missing package manifests:\n${missing}`);
+}
+export function runTreeseedWorkspaceBootstrap({ root = process.cwd() } = {}) {
+    const resolvedRoot = resolve(root);
+    const state = detectTreeseedBootstrapMode(resolvedRoot);
+    if (state.mode === 'partial') {
+        printPartialError(state);
+        return 1;
+    }
+    if (state.mode === 'workspace') {
+        console.log('Treeseed bootstrap mode: workspace (using checked-out packages/* submodules)');
+        linkWorkspacePackages(resolvedRoot, state.packages);
+        for (const entry of state.packages.filter((pkg) => pkg.build)) {
+            run('npm', ['--prefix', entry.dir, 'run', 'build:dist'], { cwd: resolvedRoot });
+        }
+        runStarlightPatchFromWorkspace(resolvedRoot, state.packages);
+        return 0;
+    }
+    console.log('Treeseed bootstrap mode: registry (using published @treeseed/* packages)');
+    runStarlightPatchFromRegistry(resolvedRoot);
+    return 0;
+}
+function isDirectEntrypoint() {
+    if (!process.argv[1]) {
+        return false;
+    }
+    const invokedPath = realpathSync(resolve(process.argv[1]));
+    const modulePath = realpathSync(fileURLToPath(import.meta.url));
+    return modulePath === invokedPath || invokedPath.endsWith('/scripts/workspace-bootstrap.ts');
+}
+if (isDirectEntrypoint()) {
+    try {
+        process.exitCode = runTreeseedWorkspaceBootstrap();
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}

package/dist/tenant/config.js

@@ -1,119 +1,11 @@
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parse as parseYaml } from "yaml";
-function resolvePackageRoot() {
-  const moduleUrl = typeof import.meta?.url === "string" ? import.meta.url : null;
-  if (!moduleUrl) {
-    return process.cwd();
-  }
-  return resolve(dirname(fileURLToPath(moduleUrl)), "../..");
-}
-const packageRoot = resolvePackageRoot();
-const packageFixtureRoot = resolve(packageRoot, ".fixtures", "treeseed-fixtures", "sites", "working-site");
-const explicitTenantRoot = process.env.TREESEED_TENANT_ROOT ? resolve(process.env.TREESEED_TENANT_ROOT) : null;
-function pathWithin(parent, candidate) {
-  const normalizedParent = resolve(parent);
-  const normalizedCandidate = resolve(candidate);
-  return normalizedCandidate === normalizedParent || normalizedCandidate.startsWith(`${normalizedParent}/`);
-}
-function collectTenantRootCandidates(start) {
-  const candidates = [];
-  let current = resolve(start);
-  while (true) {
-    candidates.push(
-      current,
-      resolve(current, ".fixtures", "treeseed-fixtures", "sites", "working-site"),
-      resolve(current, "fixture")
-    );
-    const parent = resolve(current, "..");
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  return candidates;
-}
-function uniqueCandidates(entries) {
-  return [...new Set(entries.map((entry) => resolve(entry)))];
-}
-function tenantRootCandidates() {
-  const cwd = resolve(process.cwd());
-  const cwdCandidates = collectTenantRootCandidates(cwd);
-  const packageCandidates = collectTenantRootCandidates(packageRoot);
-  if (explicitTenantRoot) {
-    return uniqueCandidates([explicitTenantRoot, ...cwdCandidates, packageFixtureRoot, ...packageCandidates]);
-  }
-  if (pathWithin(packageRoot, cwd)) {
-    return uniqueCandidates([packageFixtureRoot, ...cwdCandidates, ...packageCandidates]);
-  }
-  return uniqueCandidates([...cwdCandidates, packageFixtureRoot, ...packageCandidates]);
-}
-function resolveTenantPath(manifestPath) {
-  if (existsSync(manifestPath)) {
-    return resolve(manifestPath);
-  }
-  const candidates = tenantRootCandidates().map((root) => resolve(root, manifestPath));
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(
-    `Unable to resolve Treeseed tenant manifest at "${manifestPath}" from ${process.cwd()} or ${packageFixtureRoot}.`
-  );
-}
-function resolveTenantRoot() {
-  const candidates = tenantRootCandidates();
-  for (const candidate of candidates) {
-    if (existsSync(resolve(candidate, "src/manifest.yaml"))) {
-      return candidate;
-    }
-  }
-  throw new Error(
-    `Unable to resolve a Treeseed tenant root from ${process.cwd()} or ${packageFixtureRoot}.`
-  );
-}
-function defineTreeseedTenant(tenantConfig) {
-  return tenantConfig;
-}
-function loadTreeseedManifest(manifestPath = "./src/manifest.yaml") {
-  const resolvedManifestPath = resolveTenantPath(manifestPath);
-  const tenantRoot = resolve(dirname(resolvedManifestPath), "..");
-  const parsed = parseYaml(readFileSync(resolvedManifestPath, "utf8"));
-  const tenantConfig = defineTreeseedTenant({
-    ...parsed,
-    siteConfigPath: resolve(tenantRoot, parsed.siteConfigPath),
-    content: Object.fromEntries(
-      Object.entries(parsed.content ?? {}).map(([collectionName, rootPath]) => [
-        collectionName,
-        resolve(tenantRoot, String(rootPath))
-      ])
-    ),
-    overrides: parsed.overrides ? {
-      pagesRoot: parsed.overrides.pagesRoot ? resolve(tenantRoot, parsed.overrides.pagesRoot) : void 0,
-      stylesRoot: parsed.overrides.stylesRoot ? resolve(tenantRoot, parsed.overrides.stylesRoot) : void 0,
-      componentsRoot: parsed.overrides.componentsRoot ? resolve(tenantRoot, parsed.overrides.componentsRoot) : void 0
-    } : void 0
-  });
-  Object.defineProperty(tenantConfig, "__tenantRoot", {
-    value: tenantRoot,
-    enumerable: false
-  });
-  return tenantConfig;
-}
-const loadTreeseedTenantManifest = loadTreeseedManifest;
-const resolveTreeseedTenantRoot = resolveTenantRoot;
-function getTenantContentRoot(tenantConfig, collectionName) {
-  const root = tenantConfig.content[collectionName];
-  if (!root) {
-    throw new Error(`Unknown tenant content collection: ${collectionName}`);
-  }
-  return root;
-}
-function tenantFeatureEnabled(tenantConfig, featureName) {
-  return tenantConfig.features?.[featureName] !== false;
-}
+import {
+  defineTreeseedTenant,
+  getTenantContentRoot,
+  loadTreeseedManifest,
+  loadTreeseedTenantManifest,
+  resolveTreeseedTenantRoot,
+  tenantFeatureEnabled
+} from "@treeseed/sdk/platform/tenant-config";
 export {
   defineTreeseedTenant,
   getTenantContentRoot,

package/dist/utils/books-data.js

@@ -1,78 +1,10 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import path from "node:path";
-import { parse as parseYaml } from "yaml";
-import { getTenantContentRoot } from "../tenant/config.js";
-import { RUNTIME_PROJECT_ROOT, RUNTIME_TENANT } from "../tenant/runtime-config.js";
-function sortPaths(paths) {
-  return [...paths].sort((left, right) => left.localeCompare(right, void 0, { numeric: true, sensitivity: "base" }));
-}
-function collectMarkdownFiles(rootPath) {
-  const stats = statSync(rootPath);
-  if (stats.isFile()) {
-    return [rootPath];
-  }
-  return sortPaths(
-    readdirSync(rootPath, { withFileTypes: true }).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 parseFrontmatter(filePath) {
-  const raw = readFileSync(filePath, "utf8");
-  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!match) {
-    throw new Error(`Book content entry is missing frontmatter: ${filePath}`);
-  }
-  return parseYaml(match[1]);
-}
-function inferDocsLibraryDownload(book) {
-  const title = book?.title ? `${book.title} Library` : "Knowledge Library";
-  return {
-    downloadFileName: "treeseed-knowledge.md",
-    downloadHref: "/books/treeseed-knowledge.md",
-    downloadTitle: title
-  };
-}
-function buildTenantBookRuntime(tenantConfig, options = {}) {
-  const projectRoot = options.projectRoot ?? process.cwd();
-  const booksContentRoot = path.resolve(projectRoot, getTenantContentRoot(tenantConfig, "books"));
-  const books = collectMarkdownFiles(booksContentRoot).map((filePath) => {
-    const frontmatter = parseFrontmatter(filePath);
-    return {
-      ...frontmatter,
-      id: path.basename(filePath, path.extname(filePath))
-    };
-  }).sort((left, right) => left.order - right.order);
-  const docsHomePath = options.docsHomePath ?? "/knowledge/";
-  const docsLibraryDownload = options.docsLibraryDownload ?? inferDocsLibraryDownload(tenantConfig);
-  return {
-    BOOKS: books,
-    BOOKS_LINK: {
-      label: "Books",
-      link: docsHomePath
-    },
-    TREESEED_LINKS: {
-      home: docsHomePath
-    },
-    TREESEED_LIBRARY_DOWNLOAD: docsLibraryDownload
-  };
-}
-const runtime = buildTenantBookRuntime(RUNTIME_TENANT, {
-  projectRoot: RUNTIME_PROJECT_ROOT,
-  docsLibraryDownload: {
-    downloadFileName: "treeseed-knowledge.md",
-    downloadHref: "/books/treeseed-knowledge.md",
-    downloadTitle: "TreeSeed Knowledge Library"
-  }
-});
-const { BOOKS, BOOKS_LINK, TREESEED_LINKS, TREESEED_LIBRARY_DOWNLOAD } = runtime;
+import {
+  BOOKS,
+  BOOKS_LINK,
+  TREESEED_LIBRARY_DOWNLOAD,
+  TREESEED_LINKS,
+  buildTenantBookRuntime
+} from "@treeseed/sdk/platform/books-data";
 export {
   BOOKS,
   BOOKS_LINK,