@treeseed/core 0.1.2 → 0.3.2

package/dist/plugins/runtime.js

@@ -1,120 +1,10 @@
-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
-  };
-}
+import {
+  loadTreeseedPluginRuntime,
+  loadTreeseedPlugins,
+  resolveTreeseedGraphRankingProvider
+} from "@treeseed/sdk/platform/plugins";
 export {
   loadTreeseedPluginRuntime,
-  loadTreeseedPlugins
+  loadTreeseedPlugins,
+  resolveTreeseedGraphRankingProvider
 };

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/run-fixture-astro-command.js

@@ -1,10 +1,26 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
+import { join, resolve } from 'node:path';
 import { fixtureRoot, packageRoot } from './paths.js';
 const [command, ...rest] = process.argv.slice(2);
 if (!command) {
     console.error('Usage: node ./scripts/run-fixture-astro-command.mjs <check|build|preview|dev> [...args]');
     process.exit(1);
 }
+function ensureFixtureDefaultPluginPackage() {
+    const packageDir = resolve(fixtureRoot, 'node_modules', '@treeseed', 'core');
+    const pluginEntryPath = resolve(packageRoot, 'dist', 'plugin-default.js');
+    mkdirSync(packageDir, { recursive: true });
+    writeFileSync(join(packageDir, 'package.json'), `${JSON.stringify({
+        name: '@treeseed/core',
+        type: 'commonjs',
+        exports: {
+            './plugin-default': './plugin-default.cjs',
+        },
+    }, null, 2)}\n`, 'utf8');
+    writeFileSync(join(packageDir, 'plugin-default.cjs'), `module.exports = require(${JSON.stringify(pluginEntryPath)});\n`, 'utf8');
+}
+ensureFixtureDefaultPluginPackage();
 const result = spawnSync('npx', ['astro', command, '--root', fixtureRoot, ...rest], {
     cwd: packageRoot,
     stdio: 'inherit',

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/agents/contracts/messages.d.ts

@@ -1,88 +1 @@
-export interface QuestionPriorityUpdatedMessage {
-    questionId: string;
-    reason: string;
-    plannerRunId: string;
-}
-export interface ObjectivePriorityUpdatedMessage {
-    objectiveId: string;
-    reason: string;
-    plannerRunId: string;
-}
-export interface ArchitectureUpdatedMessage {
-    objectiveId: string;
-    knowledgeId: string;
-    architectRunId: string;
-}
-export interface SubscriberNotifiedMessage {
-    email: string;
-    itemCount: number;
-    notifierRunId: string;
-}
-export interface ResearchStartedMessage {
-    questionId: string;
-    researcherRunId: string;
-}
-export interface ResearchCompletedMessage {
-    questionId: string;
-    knowledgeId: string | null;
-    researcherRunId: string;
-}
-export interface TaskCompleteMessage {
-    branchName: string | null;
-    changedTargets: string[];
-    engineerRunId: string;
-}
-export interface TaskWaitingMessage {
-    blockingReason: string;
-    engineerRunId: string;
-}
-export interface TaskFailedMessage {
-    failureSummary: string;
-    engineerRunId: string;
-}
-export interface TaskVerifiedMessage {
-    branchName: string | null;
-    reviewerRunId: string;
-}
-export interface ReviewFailedMessage {
-    failureSummary: string;
-    reviewerRunId: string;
-}
-export interface ReviewWaitingMessage {
-    blockingReason: string;
-    reviewerRunId: string;
-}
-export interface ReleaseStartedMessage {
-    taskRunId: string | null;
-    releaserRunId: string;
-}
-export interface ReleaseCompletedMessage {
-    releaseSummary: string;
-    releaserRunId: string;
-}
-export interface ReleaseFailedMessage {
-    failureSummary: string;
-    releaserRunId: string;
-}
-export interface AgentMessageContracts {
-    question_priority_updated: QuestionPriorityUpdatedMessage;
-    objective_priority_updated: ObjectivePriorityUpdatedMessage;
-    architecture_updated: ArchitectureUpdatedMessage;
-    subscriber_notified: SubscriberNotifiedMessage;
-    research_started: ResearchStartedMessage;
-    research_completed: ResearchCompletedMessage;
-    task_complete: TaskCompleteMessage;
-    task_waiting: TaskWaitingMessage;
-    task_failed: TaskFailedMessage;
-    task_verified: TaskVerifiedMessage;
-    review_failed: ReviewFailedMessage;
-    review_waiting: ReviewWaitingMessage;
-    release_started: ReleaseStartedMessage;
-    release_completed: ReleaseCompletedMessage;
-    release_failed: ReleaseFailedMessage;
-}
-export type AgentMessageType = keyof AgentMessageContracts;
-export type AgentMessagePayload<TType extends AgentMessageType> = AgentMessageContracts[TType];
-export declare const AGENT_MESSAGE_TYPES: readonly ["question_priority_updated", "objective_priority_updated", "architecture_updated", "subscriber_notified", "research_started", "research_completed", "task_complete", "task_waiting", "task_failed", "task_verified", "review_failed", "review_waiting", "release_started", "release_completed", "release_failed"];
-export declare function parseAgentMessagePayload<TType extends AgentMessageType>(type: TType, payloadJson: string): AgentMessagePayload<TType>;
-export declare function serializeAgentMessagePayload<TType extends AgentMessageType>(type: TType, payload: AgentMessagePayload<TType>): Record<string, unknown>;
+export * from '@treeseed/sdk/utils/agents/contracts/messages';