@treeseed/core 0.1.2 → 0.3.0

package/dist/environment.d.ts

@@ -1,130 +1,2 @@
-import type { TreeseedDeployConfig, TreeseedTenantConfig } from './contracts';
-import { type LoadedTreeseedPluginEntry } from './plugins/runtime';
-export declare const TREESEED_ENVIRONMENT_SCOPES: readonly ["local", "staging", "prod"];
-export declare const TREESEED_ENVIRONMENT_REQUIREMENTS: readonly ["required", "conditional", "optional"];
-export declare const TREESEED_ENVIRONMENT_TARGETS: readonly ["local-file", "wrangler-dev-vars", "github-secret", "github-variable", "cloudflare-secret", "cloudflare-var", "config-file"];
-export declare const TREESEED_ENVIRONMENT_PURPOSES: readonly ["dev", "save", "deploy", "destroy", "config"];
-export declare const TREESEED_ENVIRONMENT_SENSITIVITY: readonly ["secret", "plain", "derived"];
-export type TreeseedEnvironmentScope = (typeof TREESEED_ENVIRONMENT_SCOPES)[number];
-export type TreeseedEnvironmentRequirement = (typeof TREESEED_ENVIRONMENT_REQUIREMENTS)[number];
-export type TreeseedEnvironmentTarget = (typeof TREESEED_ENVIRONMENT_TARGETS)[number];
-export type TreeseedEnvironmentPurpose = (typeof TREESEED_ENVIRONMENT_PURPOSES)[number];
-export type TreeseedEnvironmentSensitivity = (typeof TREESEED_ENVIRONMENT_SENSITIVITY)[number];
-export type TreeseedEnvironmentValidation = {
-    kind: 'string' | 'nonempty' | 'boolean' | 'number' | 'url' | 'email';
-} | {
-    kind: 'enum';
-    values: string[];
-};
-export type TreeseedEnvironmentValueResolver = string | ((context: TreeseedEnvironmentContext, scope: TreeseedEnvironmentScope) => string);
-export type TreeseedMachineSecretPayload = {
-    algorithm: 'aes-256-gcm';
-    iv: string;
-    tag: string;
-    ciphertext: string;
-};
-export type TreeseedMachineConfig = {
-    version: number;
-    project: {
-        tenantRoot: string;
-        tenantId: string;
-        slug: string;
-        name: string;
-        siteUrl: string;
-        overlayPath?: string;
-    };
-    settings: {
-        sync: {
-            github: boolean;
-            cloudflare: boolean;
-        };
-    };
-    environments: Record<TreeseedEnvironmentScope, {
-        values: Record<string, string>;
-        secrets: Record<string, TreeseedMachineSecretPayload>;
-    }>;
-};
-export type TreeseedEnvironmentContext = {
-    deployConfig: TreeseedDeployConfig;
-    tenantConfig?: TreeseedTenantConfig;
-    plugins: LoadedTreeseedPluginEntry[];
-    tenantRoot: string;
-};
-export type TreeseedEnvironmentEntry = {
-    id: string;
-    label: string;
-    group: string;
-    description: string;
-    howToGet: string;
-    sensitivity: TreeseedEnvironmentSensitivity;
-    targets: TreeseedEnvironmentTarget[];
-    scopes: TreeseedEnvironmentScope[];
-    requirement: TreeseedEnvironmentRequirement;
-    purposes: TreeseedEnvironmentPurpose[];
-    validation?: TreeseedEnvironmentValidation;
-    sourcePriority?: string[];
-    defaultValue?: TreeseedEnvironmentValueResolver;
-    localDefaultValue?: TreeseedEnvironmentValueResolver;
-    isRelevant?: (context: TreeseedEnvironmentContext, scope: TreeseedEnvironmentScope, purpose?: TreeseedEnvironmentPurpose) => boolean;
-    requiredWhen?: (context: TreeseedEnvironmentContext, scope: TreeseedEnvironmentScope, purpose?: TreeseedEnvironmentPurpose) => boolean;
-};
-export type TreeseedEnvironmentEntryYaml = Omit<TreeseedEnvironmentEntry, 'id' | 'defaultValue' | 'localDefaultValue' | 'isRelevant' | 'requiredWhen'> & {
-    defaultValueRef?: string;
-    localDefaultValueRef?: string;
-    relevanceRef?: string;
-    requiredWhenRef?: string;
-};
-export type TreeseedEnvironmentEntryOverride = Partial<Omit<TreeseedEnvironmentEntryYaml, 'id'>> & {
-    id?: string;
-};
-export type TreeseedEnvironmentRegistryOverlay = {
-    entries?: Record<string, TreeseedEnvironmentEntryOverride>;
-};
-export type TreeseedResolvedEnvironmentRegistry = {
-    context: TreeseedEnvironmentContext;
-    entries: TreeseedEnvironmentEntry[];
-};
-export type TreeseedEnvironmentValidationProblem = {
-    id: string;
-    label: string;
-    reason: 'missing' | 'invalid';
-    message: string;
-    entry: TreeseedEnvironmentEntry;
-};
-export type TreeseedEnvironmentValidationResult = {
-    ok: boolean;
-    entries: TreeseedEnvironmentEntry[];
-    required: TreeseedEnvironmentEntry[];
-    missing: TreeseedEnvironmentValidationProblem[];
-    invalid: TreeseedEnvironmentValidationProblem[];
-};
-export declare function loadTreeseedEnvironmentOverlay(tenantRoot: string): {
-    path: string;
-    overlay: TreeseedEnvironmentRegistryOverlay;
-};
-export declare function resolveTreeseedEnvironmentContext(options?: {
-    deployConfig?: TreeseedDeployConfig;
-    tenantConfig?: TreeseedTenantConfig;
-    plugins?: LoadedTreeseedPluginEntry[];
-}): TreeseedEnvironmentContext;
-export declare function resolveTreeseedEnvironmentRegistry(options?: {
-    deployConfig?: TreeseedDeployConfig;
-    tenantConfig?: TreeseedTenantConfig;
-    plugins?: LoadedTreeseedPluginEntry[];
-}): TreeseedResolvedEnvironmentRegistry;
-export declare function isTreeseedEnvironmentEntryRelevant(entry: TreeseedEnvironmentEntry, context: TreeseedEnvironmentContext, scope: TreeseedEnvironmentScope, purpose?: TreeseedEnvironmentPurpose): boolean;
-export declare function getTreeseedEnvironmentSuggestedValues(options: {
-    scope: TreeseedEnvironmentScope;
-    purpose?: TreeseedEnvironmentPurpose;
-    deployConfig?: TreeseedDeployConfig;
-    tenantConfig?: TreeseedTenantConfig;
-    plugins?: LoadedTreeseedPluginEntry[];
-}): Record<string, string>;
-export declare function validateTreeseedEnvironmentValues(options: {
-    values: Record<string, string | undefined>;
-    scope: TreeseedEnvironmentScope;
-    purpose: TreeseedEnvironmentPurpose;
-    deployConfig?: TreeseedDeployConfig;
-    tenantConfig?: TreeseedTenantConfig;
-    plugins?: LoadedTreeseedPluginEntry[];
-}): TreeseedEnvironmentValidationResult;
+export { getTreeseedEnvironmentSuggestedValues, isTreeseedEnvironmentEntryRelevant, loadTreeseedEnvironmentOverlay, resolveTreeseedEnvironmentContext, resolveTreeseedEnvironmentRegistry, TREESEED_ENVIRONMENT_PURPOSES, TREESEED_ENVIRONMENT_REQUIREMENTS, TREESEED_ENVIRONMENT_SCOPES, TREESEED_ENVIRONMENT_SENSITIVITY, TREESEED_ENVIRONMENT_TARGETS, validateTreeseedEnvironmentValues, } from '@treeseed/sdk/platform/environment';
+export type * from '@treeseed/sdk/platform/environment';

package/dist/environment.js

@@ -1,314 +1,16 @@
-import { randomBytes } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parse as parseYaml } from "yaml";
-import { loadTreeseedDeployConfig } from "./deploy/config.js";
-import { loadTreeseedPlugins } from "./plugins/runtime.js";
-import { loadTreeseedManifest } from "./tenant/config.js";
-const TREESEED_ENVIRONMENT_SCOPES = ["local", "staging", "prod"];
-const TREESEED_ENVIRONMENT_REQUIREMENTS = ["required", "conditional", "optional"];
-const TREESEED_ENVIRONMENT_TARGETS = [
-  "local-file",
-  "wrangler-dev-vars",
-  "github-secret",
-  "github-variable",
-  "cloudflare-secret",
-  "cloudflare-var",
-  "config-file"
-];
-const TREESEED_ENVIRONMENT_PURPOSES = ["dev", "save", "deploy", "destroy", "config"];
-const TREESEED_ENVIRONMENT_SENSITIVITY = ["secret", "plain", "derived"];
-const moduleDir = dirname(fileURLToPath(import.meta.url));
-const CORE_ENVIRONMENT_PATH = resolve(moduleDir, "env.yaml");
-const TENANT_ENVIRONMENT_OVERLAY_PATH = "src/env.yaml";
-function loadOptionalTenantConfig() {
-  try {
-    return loadTreeseedManifest();
-  } catch {
-    return void 0;
-  }
-}
-function turnstileEnabled(context) {
-  return context.deployConfig.turnstile?.enabled !== false;
-}
-function smtpEnabled(context) {
-  return context.deployConfig.smtp?.enabled === true;
-}
-function generatedSecret(bytes = 24) {
-  return randomBytes(bytes).toString("hex");
-}
-const VALUE_RESOLVERS = {
-  generatedSecret: () => generatedSecret(),
-  localFormsBypassDefault: () => "true"
-};
-const PREDICATES = {
-  turnstileEnabled: (context) => turnstileEnabled(context),
-  turnstileNonLocal: (context, scope) => turnstileEnabled(context) && scope !== "local",
-  smtpEnabled: (context) => smtpEnabled(context),
-  smtpNonLocal: (context, scope) => smtpEnabled(context) && scope !== "local"
-};
-function deepMerge(left, right) {
-  if (Array.isArray(left) && Array.isArray(right)) {
-    return [...right];
-  }
-  if (left && typeof left === "object" && !Array.isArray(left) && right && typeof right === "object" && !Array.isArray(right)) {
-    const result = { ...left };
-    for (const [key, value] of Object.entries(right)) {
-      result[key] = key in result ? deepMerge(result[key], value) : value;
-    }
-    return result;
-  }
-  return right;
-}
-function normalizeOverlay(raw, label) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(`Invalid Treeseed environment registry overlay from ${label}.`);
-  }
-  const overlay = raw;
-  if (overlay.entries === void 0) {
-    return { entries: {} };
-  }
-  if (!overlay.entries || typeof overlay.entries !== "object" || Array.isArray(overlay.entries)) {
-    throw new Error(`Invalid Treeseed environment registry overlay entries in ${label}.`);
-  }
-  return overlay;
-}
-function readYamlOverlayIfPresent(filePath) {
-  if (!existsSync(filePath)) {
-    return null;
-  }
-  return normalizeOverlay(parseYaml(readFileSync(filePath, "utf8")), filePath);
-}
-function pluginEnvironmentCandidates(baseDir) {
-  const dir = resolve(baseDir);
-  return [
-    resolve(dir, "env.yaml"),
-    resolve(dir, "src/env.yaml"),
-    resolve(dir, "../env.yaml"),
-    resolve(dir, "../src/env.yaml"),
-    resolve(dir, "../../env.yaml"),
-    resolve(dir, "../../src/env.yaml")
-  ];
-}
-function readPluginEnvironmentOverlay(baseDir) {
-  for (const candidate of pluginEnvironmentCandidates(baseDir)) {
-    const overlay = readYamlOverlayIfPresent(candidate);
-    if (overlay) {
-      return { path: candidate, overlay };
-    }
-  }
-  return null;
-}
-function loadTreeseedEnvironmentOverlay(tenantRoot) {
-  const overlayPath = resolve(tenantRoot, TENANT_ENVIRONMENT_OVERLAY_PATH);
-  return {
-    path: overlayPath,
-    overlay: readYamlOverlayIfPresent(overlayPath) ?? { entries: {} }
-  };
-}
-function resolveNamedValueResolver(ref) {
-  if (!ref) return void 0;
-  const resolver = VALUE_RESOLVERS[ref];
-  if (!resolver) {
-    throw new Error(`Unknown Treeseed environment value resolver "${ref}".`);
-  }
-  return resolver;
-}
-function resolveNamedPredicate(ref) {
-  if (!ref) return void 0;
-  const predicate = PREDICATES[ref];
-  if (!predicate) {
-    throw new Error(`Unknown Treeseed environment predicate "${ref}".`);
-  }
-  return predicate;
-}
-function materializeEntry(id, entry) {
-  return {
-    ...entry,
-    id,
-    defaultValue: resolveNamedValueResolver(entry.defaultValueRef),
-    localDefaultValue: resolveNamedValueResolver(entry.localDefaultValueRef),
-    isRelevant: resolveNamedPredicate(entry.relevanceRef),
-    requiredWhen: resolveNamedPredicate(entry.requiredWhenRef)
-  };
-}
-function mergeEntryYaml(baseEntry, id, override) {
-  const merged = baseEntry ? deepMerge(baseEntry, override) : override;
-  if (typeof merged.label !== "string" || typeof merged.group !== "string" || typeof merged.description !== "string" || typeof merged.howToGet !== "string" || !Array.isArray(merged.targets) || !Array.isArray(merged.scopes) || typeof merged.requirement !== "string" || !Array.isArray(merged.purposes) || typeof merged.sensitivity !== "string") {
-    throw new Error(`Treeseed environment registry entry "${id}" is missing required metadata after merge.`);
-  }
-  return merged;
-}
-function collectOverlaySources(context) {
-  const sources = [];
-  const coreOverlay = readYamlOverlayIfPresent(CORE_ENVIRONMENT_PATH);
-  if (!coreOverlay) {
-    throw new Error(`Treeseed core environment registry file was not found at ${CORE_ENVIRONMENT_PATH}.`);
-  }
-  sources.push({ label: CORE_ENVIRONMENT_PATH, overlay: coreOverlay });
-  for (const pluginEntry of context.plugins) {
-    const fileOverlay = readPluginEnvironmentOverlay(pluginEntry.baseDir);
-    if (fileOverlay) {
-      sources.push({ label: fileOverlay.path, overlay: fileOverlay.overlay });
-    }
-    const overlaySource = pluginEntry.plugin.environmentRegistry;
-    if (!overlaySource) {
-      continue;
-    }
-    const pluginContext = {
-      projectRoot: context.tenantRoot,
-      tenantConfig: context.tenantConfig,
-      deployConfig: context.deployConfig,
-      pluginConfig: pluginEntry.config
-    };
-    const overlay = typeof overlaySource === "function" ? overlaySource(pluginContext) : overlaySource;
-    if (overlay) {
-      sources.push({
-        label: `plugin ${pluginEntry.package}`,
-        overlay: normalizeOverlay(overlay, `plugin ${pluginEntry.package}`)
-      });
-    }
-  }
-  const tenantOverlay = loadTreeseedEnvironmentOverlay(context.tenantRoot);
-  sources.push({ label: tenantOverlay.path, overlay: tenantOverlay.overlay });
-  return sources;
-}
-function resolveTreeseedEnvironmentContext(options = {}) {
-  const deployConfig = options.deployConfig ?? loadTreeseedDeployConfig();
-  const tenantConfig = options.tenantConfig ?? loadOptionalTenantConfig();
-  const plugins = options.plugins ?? loadTreeseedPlugins(deployConfig);
-  const tenantRoot = deployConfig.__tenantRoot ?? tenantConfig?.__tenantRoot ?? process.cwd();
-  return {
-    deployConfig,
-    tenantConfig,
-    plugins,
-    tenantRoot
-  };
-}
-function resolveTreeseedEnvironmentRegistry(options = {}) {
-  const context = resolveTreeseedEnvironmentContext(options);
-  const entriesById = /* @__PURE__ */ new Map();
-  const order = [];
-  for (const source of collectOverlaySources(context)) {
-    for (const [id, override] of Object.entries(source.overlay.entries ?? {})) {
-      const current = entriesById.get(id);
-      entriesById.set(id, mergeEntryYaml(current, id, override ?? {}));
-      if (!current) {
-        order.push(id);
-      }
-    }
-  }
-  return {
-    context,
-    entries: order.map((id) => materializeEntry(id, entriesById.get(id)))
-  };
-}
-function isTreeseedEnvironmentEntryRelevant(entry, context, scope, purpose) {
-  if (!entry.scopes.includes(scope)) {
-    return false;
-  }
-  if (purpose && !entry.purposes.includes(purpose)) {
-    return false;
-  }
-  if (entry.isRelevant) {
-    return entry.isRelevant(context, scope, purpose);
-  }
-  return true;
-}
-function isEntryRequired(entry, context, scope, purpose) {
-  if (entry.requirement === "required") {
-    return true;
-  }
-  if (entry.requirement === "conditional") {
-    return entry.requiredWhen ? entry.requiredWhen(context, scope, purpose) : true;
-  }
-  return false;
-}
-function materializeDefaultValue(entry, context, scope) {
-  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;
-}
-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)
-  );
-}
-function valuePresent(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function validateValue(entry, value) {
-  if (!entry.validation) {
-    return null;
-  }
-  switch (entry.validation.kind) {
-    case "string":
-    case "nonempty":
-      return valuePresent(value) ? null : `${entry.id} must be a non-empty string.`;
-    case "boolean":
-      return /^(true|false|1|0)$/i.test(value) ? null : `${entry.id} must be true or false.`;
-    case "number":
-      return Number.isFinite(Number(value)) ? null : `${entry.id} must be a number.`;
-    case "url":
-      try {
-        new URL(value);
-        return null;
-      } catch {
-        return `${entry.id} must be a valid URL.`;
-      }
-    case "email":
-      return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) ? null : `${entry.id} must be a valid email address.`;
-    case "enum":
-      return entry.validation.values.includes(value) ? null : `${entry.id} must be one of: ${entry.validation.values.join(", ")}.`;
-    default:
-      return null;
-  }
-}
-function validateTreeseedEnvironmentValues(options) {
-  const registry = resolveTreeseedEnvironmentRegistry(options);
-  const relevantEntries = registry.entries.filter(
-    (entry) => isTreeseedEnvironmentEntryRelevant(entry, registry.context, options.scope, options.purpose)
-  );
-  const requiredEntries = relevantEntries.filter(
-    (entry) => isEntryRequired(entry, registry.context, options.scope, options.purpose)
-  );
-  const missing = [];
-  const invalid = [];
-  for (const entry of requiredEntries) {
-    const value = options.values[entry.id];
-    if (!valuePresent(value)) {
-      missing.push({
-        id: entry.id,
-        label: entry.label,
-        reason: "missing",
-        message: `${entry.id} is required for ${options.purpose} (${options.scope}). ${entry.howToGet}`,
-        entry
-      });
-      continue;
-    }
-    const validationMessage = validateValue(entry, value);
-    if (validationMessage) {
-      invalid.push({
-        id: entry.id,
-        label: entry.label,
-        reason: "invalid",
-        message: validationMessage,
-        entry
-      });
-    }
-  }
-  return {
-    ok: missing.length === 0 && invalid.length === 0,
-    entries: relevantEntries,
-    required: requiredEntries,
-    missing,
-    invalid
-  };
-}
+import {
+  getTreeseedEnvironmentSuggestedValues,
+  isTreeseedEnvironmentEntryRelevant,
+  loadTreeseedEnvironmentOverlay,
+  resolveTreeseedEnvironmentContext,
+  resolveTreeseedEnvironmentRegistry,
+  TREESEED_ENVIRONMENT_PURPOSES,
+  TREESEED_ENVIRONMENT_REQUIREMENTS,
+  TREESEED_ENVIRONMENT_SCOPES,
+  TREESEED_ENVIRONMENT_SENSITIVITY,
+  TREESEED_ENVIRONMENT_TARGETS,
+  validateTreeseedEnvironmentValues
+} from "@treeseed/sdk/platform/environment";
 export {
   TREESEED_ENVIRONMENT_PURPOSES,
   TREESEED_ENVIRONMENT_REQUIREMENTS,

package/dist/index.js

@@ -12,6 +12,7 @@ import {
   getTreeseedDeployProvider,
   getTreeseedDocsProvider,
   getTreeseedFormsProvider,
+  getTreeseedOperationsProvider,
   getTreeseedSiteProvider,
   isTreeseedSmtpEnabled,
   isTreeseedTurnstileEnabled,
@@ -58,6 +59,7 @@ export {
   getTreeseedDocsProvider,
   getTreeseedEnvironmentSuggestedValues,
   getTreeseedFormsProvider,
+  getTreeseedOperationsProvider,
   getTreeseedSiteProvider,
   isTreeseedEnvironmentEntryRelevant,
   isTreeseedSmtpEnabled,

package/dist/plugins/builtin/default-plugin.js

@@ -1,8 +1,10 @@
+import { createDefaultGraphRankingProvider } from "@treeseed/sdk";
 import { defineTreeseedPlugin } from "../plugin.js";
 var default_plugin_default = defineTreeseedPlugin({
   id: "treeseed-core-default",
   provides: {
     forms: ["store_only", "notify_admin", "full_email"],
+    operations: ["default"],
     agents: {
       execution: ["stub", "manual", "copilot"],
       mutation: ["local_branch"],
@@ -25,6 +27,9 @@ var default_plugin_default = defineTreeseedPlugin({
       docs: ["default"]
     },
     site: ["default"]
+  },
+  graphRankingProviders: {
+    default: createDefaultGraphRankingProvider()
   }
 });
 export {

package/dist/plugins/constants.d.ts

@@ -1,21 +1 @@
-export declare const TREESEED_DEFAULT_PLUGIN_PACKAGE = "@treeseed/core/plugin-default";
-export declare const TREESEED_DEFAULT_PROVIDER_SELECTIONS: {
-    forms: string;
-    agents: {
-        execution: string;
-        mutation: string;
-        repository: string;
-        verification: string;
-        notification: string;
-        research: string;
-    };
-    deploy: string;
-    content: {
-        docs: string;
-    };
-    site: string;
-};
-export declare const TREESEED_DEFAULT_PLUGIN_REFERENCES: {
-    package: string;
-    enabled: boolean;
-}[];
+export { TREESEED_DEFAULT_PLUGIN_PACKAGE, TREESEED_DEFAULT_PLUGIN_REFERENCES, TREESEED_DEFAULT_PROVIDER_SELECTIONS, } from '@treeseed/sdk/platform/plugins';

package/dist/plugins/constants.js

@@ -1,26 +1,8 @@
-const TREESEED_DEFAULT_PLUGIN_PACKAGE = "@treeseed/core/plugin-default";
-const TREESEED_DEFAULT_PROVIDER_SELECTIONS = {
-  forms: "store_only",
-  agents: {
-    execution: "stub",
-    mutation: "local_branch",
-    repository: "stub",
-    verification: "stub",
-    notification: "stub",
-    research: "stub"
-  },
-  deploy: "cloudflare",
-  content: {
-    docs: "default"
-  },
-  site: "default"
-};
-const TREESEED_DEFAULT_PLUGIN_REFERENCES = [
-  {
-    package: TREESEED_DEFAULT_PLUGIN_PACKAGE,
-    enabled: true
-  }
-];
+import {
+  TREESEED_DEFAULT_PLUGIN_PACKAGE,
+  TREESEED_DEFAULT_PLUGIN_REFERENCES,
+  TREESEED_DEFAULT_PROVIDER_SELECTIONS
+} from "@treeseed/sdk/platform/plugins";
 export {
   TREESEED_DEFAULT_PLUGIN_PACKAGE,
   TREESEED_DEFAULT_PLUGIN_REFERENCES,

package/dist/plugins/plugin.d.ts

@@ -1,42 +1,2 @@
-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;
+export { defineTreeseedPlugin } from '@treeseed/sdk/platform/plugin';
+export type * from '@treeseed/sdk/platform/plugin';

package/dist/plugins/plugin.js

@@ -1,6 +1,4 @@
-function defineTreeseedPlugin(plugin) {
-  return plugin;
-}
+import { defineTreeseedPlugin } from "@treeseed/sdk/platform/plugin";
 export {
   defineTreeseedPlugin
 };

package/dist/plugins/runtime.d.ts

@@ -12,6 +12,7 @@ export declare function loadTreeseedPluginRuntime(config?: TreeseedDeployConfig)
     plugins: LoadedPluginEntry[];
     provided: {
         forms: Set<string>;
+        operations: Set<string>;
         agents: {
             execution: Set<string>;
             mutation: Set<string>;

package/dist/plugins/runtime.js

@@ -1,10 +1,11 @@
+import { existsSync } from "node:fs";
 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);
+const runtimeDir = path.dirname(fileURLToPath(import.meta.url));
 function normalizeLoadedPlugin(moduleExports, packageName) {
   const plugin = moduleExports?.default ?? moduleExports;
   if (!plugin || typeof plugin !== "object") {
@@ -15,11 +16,25 @@ function normalizeLoadedPlugin(moduleExports, packageName) {
 function isPathLikePluginReference(packageName) {
   return packageName.startsWith(".") || packageName.startsWith("/") || packageName.startsWith("file:");
 }
+function resolveLocalDefaultPluginPath() {
+  const candidates = [
+    path.resolve(runtimeDir, "../plugin-default.js"),
+    path.resolve(runtimeDir, "../../dist/plugin-default.js")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
 function loadPluginModule(packageName, tenantRoot) {
   if (packageName === TREESEED_DEFAULT_PLUGIN_PACKAGE) {
+    const localDefaultPluginPath = resolveLocalDefaultPluginPath();
+    const resolvedPath2 = localDefaultPluginPath ?? require2.resolve(packageName);
     return {
-      moduleExports: builtinDefaultPlugin,
-      baseDir: fileURLToPath(new URL("..", import.meta.url))
+      moduleExports: require2(resolvedPath2),
+      baseDir: path.dirname(resolvedPath2)
     };
   }
   if (isPathLikePluginReference(packageName)) {
@@ -56,6 +71,7 @@ function loadTreeseedPlugins(config = loadTreeseedDeployConfig()) {
 function collectProvidedIds(plugins) {
   const provided = {
     forms: /* @__PURE__ */ new Set(),
+    operations: /* @__PURE__ */ new Set(),
     agents: {
       execution: /* @__PURE__ */ new Set(),
       mutation: /* @__PURE__ */ new Set(),
@@ -73,6 +89,7 @@ function collectProvidedIds(plugins) {
   };
   for (const { plugin } of plugins) {
     for (const id of plugin.provides?.forms ?? []) provided.forms.add(id);
+    for (const id of plugin.provides?.operations ?? []) provided.operations.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);
@@ -99,6 +116,7 @@ function loadTreeseedPluginRuntime(config = loadTreeseedDeployConfig()) {
   const provided = collectProvidedIds(plugins);
   const providers = config.providers;
   assertSelectedProvider(provided.forms, "forms", providers.forms);
+  assertSelectedProvider(provided.operations, "operations", providers.operations);
   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);