@treeseed/agent 0.1.2

package/dist/agents/registry.js

@@ -0,0 +1,91 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { getTreeseedAgentProviderSelections } from "@treeseed/core/deploy/runtime";
+import { resolveTreeseedTenantRoot } from "@treeseed/core/tenant-config";
+import { resolveAgentRuntimeProviders } from "../agent-runtime.js";
+const BUILTIN_HANDLER_KINDS = [
+  "planner",
+  "architect",
+  "engineer",
+  "notifier",
+  "researcher",
+  "reviewer",
+  "releaser"
+];
+const HANDLER_EXPORT_NAMES = {
+  planner: "plannerHandler",
+  architect: "architectHandler",
+  engineer: "engineerHandler",
+  notifier: "notifierHandler",
+  researcher: "researcherHandler",
+  reviewer: "reviewerHandler",
+  releaser: "releaserHandler"
+};
+function getTenantAgentHandlerModulePaths(kind, tenantRoot = resolveTreeseedTenantRoot()) {
+  return [
+    resolve(tenantRoot, "src/agents", `${kind}.js`),
+    resolve(tenantRoot, "src/agents", `${kind}.ts`)
+  ];
+}
+async function loadTenantAgentHandlerRegistry(tenantRoot = resolveTreeseedTenantRoot()) {
+  const registry = {};
+  for (const kind of BUILTIN_HANDLER_KINDS) {
+    const modulePath = getTenantAgentHandlerModulePaths(kind, tenantRoot).find((candidate) => existsSync(candidate));
+    if (!modulePath) {
+      continue;
+    }
+    let moduleExports;
+    try {
+      moduleExports = await import(
+        /* @vite-ignore */
+        pathToFileURL(modulePath).href
+      );
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to import tenant agent handler "${kind}" from ${modulePath}: ${reason}`);
+    }
+    const exportName = HANDLER_EXPORT_NAMES[kind];
+    const handler = moduleExports[exportName];
+    if (!handler) {
+      throw new Error(
+        `Tenant agent handler module "${modulePath}" must export "${exportName}" for handler kind "${kind}".`
+      );
+    }
+    const normalizedHandler = handler;
+    if (normalizedHandler.kind !== kind) {
+      throw new Error(
+        `Tenant agent handler "${exportName}" from "${modulePath}" declares kind "${normalizedHandler.kind}", but "${kind}" was expected.`
+      );
+    }
+    registry[kind] = normalizedHandler;
+  }
+  return registry;
+}
+const AGENT_HANDLER_REGISTRY = await loadTenantAgentHandlerRegistry();
+function listRegisteredAgentHandlers() {
+  const runtimeProviders = resolveAgentRuntimeProviders(resolveTreeseedTenantRoot(), getTreeseedAgentProviderSelections());
+  return [.../* @__PURE__ */ new Set([...Object.keys(AGENT_HANDLER_REGISTRY), ...runtimeProviders.handlers.keys()])];
+}
+function resolveAgentHandler(kind) {
+  const runtimeProviders = resolveAgentRuntimeProviders(resolveTreeseedTenantRoot(), getTreeseedAgentProviderSelections());
+  const handler = AGENT_HANDLER_REGISTRY[kind] ?? runtimeProviders.handlers.get(kind);
+  if (!handler) {
+    if (BUILTIN_HANDLER_KINDS.includes(kind)) {
+      const expectedPath = getTenantAgentHandlerModulePaths(kind).join('" or "');
+      const expectedExport = HANDLER_EXPORT_NAMES[kind];
+      throw new Error(
+        `No runtime handler is registered for agent handler "${kind}". Expected tenant file "${expectedPath}" exporting "${expectedExport}" or a plugin contribution.`
+      );
+    }
+    throw new Error(`No runtime handler is registered for agent handler "${kind}".`);
+  }
+  return handler;
+}
+export {
+  AGENT_HANDLER_REGISTRY,
+  getTenantAgentHandlerModulePaths,
+  listRegisteredAgentHandlers,
+  loadTenantAgentHandlerRegistry,
+  resolveAgentHandler
+};

package/dist/agents/sdk-filters.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/sdk-filters";

package/dist/agents/sdk-types.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/types";

package/dist/agents/sdk.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/sdk";

package/dist/agents/spec-loader.js

@@ -0,0 +1,53 @@
+import { AGENT_MESSAGE_TYPES } from "./contracts/messages.js";
+import { listRegisteredAgentHandlers } from "./registry.js";
+import { normalizeAgentRuntimeSpec } from "./spec-normalizer.js";
+function extractRawSpec(entry) {
+  const frontmatter = entry.frontmatter && typeof entry.frontmatter === "object" ? entry.frontmatter : {};
+  return {
+    ...frontmatter,
+    body: entry.body,
+    id: entry.id
+  };
+}
+async function loadAgentSpecs(sdk, options) {
+  const entries = typeof sdk.listRawAgentSpecs === "function" ? await sdk.listRawAgentSpecs(options) : (await sdk.listAgentSpecs(options)).map(
+    (spec) => ({
+      id: spec.slug,
+      body: "",
+      frontmatter: spec
+    })
+  );
+  const diagnostics = [];
+  const specs = [];
+  for (const entry of entries) {
+    const result = normalizeAgentRuntimeSpec(extractRawSpec(entry), {
+      registeredHandlers: listRegisteredAgentHandlers(),
+      messageTypes: [...AGENT_MESSAGE_TYPES]
+    });
+    diagnostics.push(...result.diagnostics);
+    if (result.spec) {
+      specs.push(result.spec);
+    }
+  }
+  return { specs, diagnostics };
+}
+async function loadActiveAgentSpecs(sdk) {
+  return loadAgentSpecs(sdk, { enabled: true });
+}
+async function loadAllAgentSpecs(sdk) {
+  return loadAgentSpecs(sdk);
+}
+function summarizeAgentSpec(agent) {
+  return {
+    slug: agent.slug,
+    handler: agent.handler,
+    enabled: agent.enabled,
+    triggers: agent.triggers.map((trigger) => trigger.type)
+  };
+}
+export {
+  loadActiveAgentSpecs,
+  loadAgentSpecs,
+  loadAllAgentSpecs,
+  summarizeAgentSpec
+};

package/dist/agents/spec-normalizer.js

@@ -0,0 +1,257 @@
+import {
+  AGENT_CLI_ALLOW_TOOLS
+} from "@treeseed/core/types/agents";
+import { AGENT_MESSAGE_TYPES } from "./contracts/messages.js";
+import { normalizeAgentCliOptions } from "./cli-tools.js";
+const TRIGGER_KINDS = ["schedule", "message", "follow", "startup"];
+const PERMISSION_OPERATIONS = ["get", "search", "follow", "pick", "create", "update"];
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function ensureString(value, field, diagnostics, slug) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field,
+      message: `Expected ${field} to be a non-empty string.`
+    });
+    return "";
+  }
+  return value;
+}
+function ensureBoolean(value, field, diagnostics, slug, fallback = false) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "boolean") {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field,
+      message: `Expected ${field} to be a boolean.`
+    });
+    return fallback;
+  }
+  return value;
+}
+function ensurePositiveNumber(value, field, diagnostics, slug, fallback, allowZero = false) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "number" || Number.isNaN(value) || !allowZero && value <= 0 || allowZero && value < 0) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field,
+      message: `Expected ${field} to be ${allowZero ? "a non-negative" : "a positive"} number.`
+    });
+    return fallback;
+  }
+  return value;
+}
+function normalizeTrigger(value, index, diagnostics, slug) {
+  if (!isPlainObject(value)) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field: `triggers[${index}]`,
+      message: "Expected trigger to be an object."
+    });
+    return null;
+  }
+  const type = ensureString(value.type, `triggers[${index}].type`, diagnostics, slug);
+  if (!TRIGGER_KINDS.includes(type)) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field: `triggers[${index}].type`,
+      message: `Unsupported trigger type "${String(value.type ?? "")}".`
+    });
+    return null;
+  }
+  return {
+    type,
+    cron: typeof value.cron === "string" ? value.cron : void 0,
+    messageTypes: Array.isArray(value.messageTypes) ? value.messageTypes.filter((entry) => typeof entry === "string") : [],
+    models: Array.isArray(value.models) ? value.models.filter((entry) => typeof entry === "string") : [],
+    sinceField: typeof value.sinceField === "string" ? value.sinceField : void 0,
+    runOnStart: typeof value.runOnStart === "boolean" ? value.runOnStart : false
+  };
+}
+function normalizePermissions(value, diagnostics, slug) {
+  if (!Array.isArray(value)) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field: "permissions",
+      message: "Expected permissions to be an array."
+    });
+    return [];
+  }
+  return value.flatMap((entry, index) => {
+    if (!isPlainObject(entry)) {
+      diagnostics.push({
+        severity: "error",
+        slug,
+        field: `permissions[${index}]`,
+        message: "Expected permission entry to be an object."
+      });
+      return [];
+    }
+    const model = ensureString(entry.model, `permissions[${index}].model`, diagnostics, slug);
+    const operations = Array.isArray(entry.operations) ? entry.operations.filter(
+      (operation) => typeof operation === "string" && PERMISSION_OPERATIONS.includes(operation)
+    ) : [];
+    if (!operations.length) {
+      diagnostics.push({
+        severity: "error",
+        slug,
+        field: `permissions[${index}].operations`,
+        message: "Expected at least one valid permission operation."
+      });
+    }
+    return model ? [{ model, operations }] : [];
+  });
+}
+function normalizeExecution(value, diagnostics, slug) {
+  const next = isPlainObject(value) ? value : {};
+  return {
+    maxConcurrency: ensurePositiveNumber(next.maxConcurrency, "execution.maxConcurrency", diagnostics, slug, 1),
+    timeoutSeconds: ensurePositiveNumber(next.timeoutSeconds, "execution.timeoutSeconds", diagnostics, slug, 900),
+    cooldownSeconds: ensurePositiveNumber(next.cooldownSeconds, "execution.cooldownSeconds", diagnostics, slug, 30, true),
+    leaseSeconds: ensurePositiveNumber(next.leaseSeconds, "execution.leaseSeconds", diagnostics, slug, 300),
+    retryLimit: ensurePositiveNumber(next.retryLimit, "execution.retryLimit", diagnostics, slug, 3, true),
+    branchPrefix: ensureString(next.branchPrefix ?? "agent", "execution.branchPrefix", diagnostics, slug) || "agent"
+  };
+}
+function normalizeOutputs(value, _diagnostics, _slug) {
+  const next = isPlainObject(value) ? value : {};
+  return {
+    messageTypes: Array.isArray(next.messageTypes) ? next.messageTypes.filter((entry) => typeof entry === "string") : [],
+    modelMutations: Array.isArray(next.modelMutations) ? next.modelMutations.filter((entry) => typeof entry === "string") : []
+  };
+}
+function normalizeParts(raw, slugHint, diagnostics) {
+  const slug = ensureString(raw.slug ?? slugHint, "slug", diagnostics, slugHint) || slugHint;
+  const handler = ensureString(raw.handler, "handler", diagnostics, slug);
+  const triggers = Array.isArray(raw.triggers) ? raw.triggers.map((entry, index) => normalizeTrigger(entry, index, diagnostics, slug)).filter((entry) => Boolean(entry)) : [];
+  if (!triggers.length) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field: "triggers",
+      message: "Expected at least one trigger."
+    });
+  }
+  try {
+    const cli = normalizeAgentCliOptions(raw.cli);
+    const spec = {
+      slug,
+      handler,
+      enabled: ensureBoolean(raw.enabled, "enabled", diagnostics, slug, true),
+      systemPrompt: ensureString(raw.systemPrompt, "systemPrompt", diagnostics, slug),
+      persona: ensureString(raw.persona, "persona", diagnostics, slug),
+      cli,
+      triggers,
+      triggerPolicy: isPlainObject(raw.triggerPolicy) ? {
+        maxRunsPerCycle: typeof raw.triggerPolicy.maxRunsPerCycle === "number" ? raw.triggerPolicy.maxRunsPerCycle : void 0,
+        messageBatchSize: typeof raw.triggerPolicy.messageBatchSize === "number" ? raw.triggerPolicy.messageBatchSize : void 0
+      } : void 0,
+      permissions: normalizePermissions(raw.permissions, diagnostics, slug),
+      execution: normalizeExecution(raw.execution, diagnostics, slug),
+      outputs: normalizeOutputs(raw.outputs, diagnostics, slug)
+    };
+    return spec;
+  } catch (error) {
+    diagnostics.push({
+      severity: "error",
+      slug,
+      field: "cli",
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function normalizeAgentRuntimeSpec(raw, context) {
+  const slugHint = typeof raw.slug === "string" && raw.slug ? raw.slug : "unknown-agent";
+  const diagnostics = [];
+  const parts = normalizeParts(raw, slugHint, diagnostics);
+  if (!parts) {
+    return { spec: null, diagnostics };
+  }
+  const spec = {
+    ...parts,
+    name: typeof raw.name === "string" ? raw.name : void 0,
+    description: typeof raw.description === "string" ? raw.description : void 0,
+    summary: typeof raw.summary === "string" ? raw.summary : void 0,
+    operator: typeof raw.operator === "string" ? raw.operator : void 0,
+    runtimeStatus: typeof raw.runtimeStatus === "string" ? raw.runtimeStatus : void 0,
+    capabilities: Array.isArray(raw.capabilities) ? raw.capabilities.filter((entry) => typeof entry === "string") : [],
+    tags: Array.isArray(raw.tags) ? raw.tags.filter((entry) => typeof entry === "string") : []
+  };
+  if (!context.registeredHandlers.includes(spec.handler)) {
+    diagnostics.push({
+      severity: "error",
+      slug: spec.slug,
+      field: "handler",
+      message: `No runtime handler is registered for "${spec.handler}".`
+    });
+  }
+  for (const trigger of spec.triggers) {
+    if (trigger.type === "message") {
+      const messagePermission = spec.permissions.find((permission) => permission.model === "message");
+      if (!messagePermission || !messagePermission.operations.includes("pick") || !messagePermission.operations.includes("update")) {
+        diagnostics.push({
+          severity: "error",
+          slug: spec.slug,
+          field: "permissions",
+          message: "Message-triggered agents must allow message pick and update operations."
+        });
+      }
+      for (const messageType of trigger.messageTypes ?? []) {
+        if (!context.messageTypes.includes(messageType) || !AGENT_MESSAGE_TYPES.includes(messageType)) {
+          diagnostics.push({
+            severity: "error",
+            slug: spec.slug,
+            field: "triggers.messageTypes",
+            message: `Unknown message trigger type "${messageType}".`
+          });
+        }
+      }
+    }
+    if (trigger.type === "follow" && !trigger.models?.length) {
+      diagnostics.push({
+        severity: "error",
+        slug: spec.slug,
+        field: "triggers.models",
+        message: "Follow triggers must declare at least one model."
+      });
+    }
+  }
+  for (const messageType of spec.outputs.messageTypes) {
+    if (!context.messageTypes.includes(messageType) || !AGENT_MESSAGE_TYPES.includes(messageType)) {
+      diagnostics.push({
+        severity: "error",
+        slug: spec.slug,
+        field: "outputs.messageTypes",
+        message: `Unknown emitted message type "${messageType}".`
+      });
+    }
+  }
+  if (spec.cli.allowTools?.some((tool) => !AGENT_CLI_ALLOW_TOOLS.includes(tool))) {
+    diagnostics.push({
+      severity: "error",
+      slug: spec.slug,
+      field: "cli.allowTools",
+      message: "Agent declared an unsupported tool allowance."
+    });
+  }
+  return {
+    spec: diagnostics.some((entry) => entry.severity === "error") ? null : spec,
+    diagnostics
+  };
+}
+export {
+  normalizeAgentRuntimeSpec
+};

package/dist/agents/stores/cursor-store.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/stores/cursor-store";

package/dist/agents/stores/helpers.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/stores/helpers";

package/dist/agents/stores/lease-store.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/stores/lease-store";

package/dist/agents/stores/message-store.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/stores/message-store";

package/dist/agents/stores/run-store.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/stores/run-store";

package/dist/agents/stores/subscription-store.js

@@ -0,0 +1 @@
+export * from "@treeseed/sdk/stores/subscription-store";

package/dist/agents/testing/agents-smoke.js

@@ -0,0 +1,32 @@
+import { createExecutionAdapter } from "../adapters/execution.js";
+import { createAgentTestRuntime } from "./e2e-harness.js";
+async function main() {
+  const target = process.argv[2] ?? "mvp";
+  const execution = createExecutionAdapter();
+  const runtime = await createAgentTestRuntime({
+    execution,
+    executionMode: "copilot",
+    databaseMode: process.env.TREESEED_AGENT_DATABASE_MODE === "local-d1" ? "local-d1" : "memory"
+  });
+  try {
+    await runtime.seedObjectives([{ slug: "smoke-objective" }]);
+    await runtime.seedQuestions([
+      {
+        slug: "smoke-question",
+        relatedObjectives: ["smoke-objective"]
+      }
+    ]);
+    const result = target === "mvp" ? await runtime.runCycle() : await runtime.runAgent(target);
+    const runs = await runtime.readRunLogs();
+    const messages = await runtime.readMessages();
+    console.log(JSON.stringify({
+      target,
+      result,
+      runs,
+      messages
+    }, null, 2));
+  } finally {
+    await runtime.cleanup();
+  }
+}
+void main();