@treeseed/core 0.8.2 → 0.8.4

package/dist/agents/kernel/trigger-resolver.js

@@ -1,157 +0,0 @@
-import crypto from "node:crypto";
-function followCursorKey(models) {
-  return `follow:${(models ?? []).join(",") || "all"}`;
-}
-function buildManualInvocation(agent) {
-  const scheduleLike = agent.triggers.find((trigger) => trigger.type === "schedule" || trigger.type === "startup");
-  if (!scheduleLike) {
-    return null;
-  }
-  return {
-    kind: "manual",
-    source: "manual",
-    trigger: scheduleLike
-  };
-}
-function evaluateCooldown(agent, lastRunAt) {
-  const cooldownMs = agent.execution.cooldownSeconds * 1e3;
-  return (lastRunAt ?? 0) > 0 && Date.now() - (lastRunAt ?? 0) < cooldownMs;
-}
-async function resolveMessageTrigger(agent, sdk, trigger, messageBatchSize) {
-  for (let index = 0; index < messageBatchSize; index += 1) {
-    const claimed = await sdk.claimMessage({
-      workerId: `${agent.slug}-${crypto.randomUUID()}`,
-      messageTypes: trigger.messageTypes ?? [],
-      leaseSeconds: agent.execution.leaseSeconds
-    });
-    if (claimed.payload) {
-      return {
-        kind: "ready",
-        selectedTrigger: trigger,
-        invocation: {
-          kind: "message",
-          source: "message",
-          trigger,
-          message: claimed.payload
-        }
-      };
-    }
-  }
-  return {
-    kind: "no_message_available",
-    selectedTrigger: trigger,
-    reason: `No matching messages for ${agent.slug}.`
-  };
-}
-async function resolveFollowTrigger(agent, sdk, trigger) {
-  const models = trigger.models ?? [];
-  const since = (await sdk.getCursor({
-    agentSlug: agent.slug,
-    cursorKey: followCursorKey(models)
-  })).payload ?? trigger.sinceField ?? (/* @__PURE__ */ new Date(0)).toISOString();
-  for (const model of models) {
-    const followed = await sdk.follow({
-      model,
-      since: String(since)
-    });
-    if (followed.payload.items.length) {
-      return {
-        kind: "ready",
-        selectedTrigger: trigger,
-        invocation: {
-          kind: "follow",
-          source: "follow",
-          trigger,
-          followModels: models,
-          cursorValue: String(since)
-        }
-      };
-    }
-  }
-  return {
-    kind: "no_follow_activity",
-    selectedTrigger: trigger,
-    reason: `No followed activity for ${agent.slug}.`
-  };
-}
-function resolveScheduleLikeTrigger(agent, trigger, mode, lastRunAt) {
-  if (mode !== "manual" && evaluateCooldown(agent, lastRunAt)) {
-    return {
-      kind: "blocked_by_cooldown",
-      selectedTrigger: trigger,
-      reason: `Agent ${agent.slug} is cooling down.`
-    };
-  }
-  return {
-    kind: "ready",
-    selectedTrigger: trigger,
-    invocation: {
-      kind: mode === "manual" ? "manual" : trigger.type === "startup" || trigger.runOnStart ? "startup" : "schedule",
-      source: mode === "manual" ? "manual" : trigger.type === "startup" || trigger.runOnStart ? "startup" : "schedule",
-      trigger
-    }
-  };
-}
-async function resolveTriggerDecision(input) {
-  if (input.isRunning) {
-    return {
-      kind: "blocked_by_concurrency",
-      reason: `Agent ${input.agent.slug} is already running.`
-    };
-  }
-  const mode = input.mode ?? "auto";
-  const messageBatchSize = input.agent.triggerPolicy?.messageBatchSize ?? 1;
-  const triggerGroups = {
-    message: input.agent.triggers.filter((trigger) => trigger.type === "message"),
-    follow: input.agent.triggers.filter((trigger) => trigger.type === "follow"),
-    schedule: input.agent.triggers.filter((trigger) => trigger.type === "startup" || trigger.type === "schedule")
-  };
-  for (const trigger of triggerGroups.message) {
-    const decision = await resolveMessageTrigger(input.agent, input.sdk, trigger, messageBatchSize);
-    if (!decision) {
-      continue;
-    }
-    if (decision.kind === "ready") {
-      return decision;
-    }
-  }
-  for (const trigger of triggerGroups.follow) {
-    const decision = await resolveFollowTrigger(input.agent, input.sdk, trigger);
-    if (decision.kind === "ready") {
-      return decision;
-    }
-  }
-  for (const trigger of triggerGroups.schedule) {
-    const decision = resolveScheduleLikeTrigger(input.agent, trigger, mode, input.lastRunAt);
-    if (decision.kind === "ready") {
-      return decision;
-    }
-    if (decision.kind === "blocked_by_cooldown") {
-      return decision;
-    }
-  }
-  if (mode === "manual") {
-    const invocation = buildManualInvocation(input.agent);
-    return invocation ? { kind: "ready", invocation, selectedTrigger: invocation.trigger } : { kind: "no_trigger_available", reason: `No manual-capable trigger found for ${input.agent.slug}.` };
-  }
-  if (triggerGroups.message.length) {
-    return {
-      kind: "no_message_available",
-      reason: `No matching messages for ${input.agent.slug}.`
-    };
-  }
-  if (triggerGroups.follow.length) {
-    return {
-      kind: "no_follow_activity",
-      reason: `No followed activity for ${input.agent.slug}.`
-    };
-  }
-  return {
-    kind: "no_trigger_available",
-    reason: `No runnable triggers defined for ${input.agent.slug}.`
-  };
-}
-export {
-  followCursorKey,
-  resolveTriggerDecision
-};

package/dist/agents/registry-helper.d.ts

@@ -1,4 +0,0 @@
-import type { AgentHandlerKind } from '@treeseed/sdk/types/agents';
-import type { AgentHandler } from './runtime-types.ts';
-export declare function defineAgentHandlerRegistry(registry: Partial<Record<AgentHandlerKind, AgentHandler>>): Partial<Record<string, AgentHandler<unknown, unknown>>>;
-export declare function resolveAgentHandlerFromRegistry(registry: Partial<Record<AgentHandlerKind, AgentHandler>>, kind: AgentHandlerKind): AgentHandler<unknown, unknown>;

package/dist/agents/registry-helper.js

@@ -1,14 +0,0 @@
-function defineAgentHandlerRegistry(registry) {
-  return registry;
-}
-function resolveAgentHandlerFromRegistry(registry, kind) {
-  const handler = registry[kind];
-  if (!handler) {
-    throw new Error(`No runtime handler is registered for agent handler "${kind}".`);
-  }
-  return handler;
-}
-export {
-  defineAgentHandlerRegistry,
-  resolveAgentHandlerFromRegistry
-};

package/dist/agents/registry.d.ts

@@ -1,6 +0,0 @@
-import type { AgentHandlerKind } from '@treeseed/sdk/types/agents';
-import type { AgentHandler } from './runtime-types.ts';
-export declare function getTenantAgentHandlerModulePaths(kind: AgentHandlerKind, tenantRoot?: string): string[];
-export declare function loadTenantAgentHandlerRegistry(tenantRoot?: string): Promise<Record<string, AgentHandler>>;
-export declare function listRegisteredAgentHandlers(): Promise<string[]>;
-export declare function resolveAgentHandler(kind: AgentHandlerKind): Promise<AgentHandler<unknown, unknown>>;

package/dist/agents/registry.js

@@ -1,98 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import { getTreeseedAgentProviderSelections } from "@treeseed/sdk/platform/deploy-runtime";
-import { resolveTreeseedTenantRoot } from "@treeseed/sdk/platform/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;
-}
-let agentHandlerRegistryPromise = null;
-async function getAgentHandlerRegistry() {
-  if (!agentHandlerRegistryPromise) {
-    agentHandlerRegistryPromise = loadTenantAgentHandlerRegistry();
-  }
-  return agentHandlerRegistryPromise;
-}
-async function listRegisteredAgentHandlers() {
-  const registry = await getAgentHandlerRegistry();
-  const runtimeProviders = resolveAgentRuntimeProviders(resolveTreeseedTenantRoot(), getTreeseedAgentProviderSelections());
-  return [.../* @__PURE__ */ new Set([...Object.keys(registry), ...runtimeProviders.handlers.keys()])];
-}
-async function resolveAgentHandler(kind) {
-  const registry = await getAgentHandlerRegistry();
-  const runtimeProviders = resolveAgentRuntimeProviders(resolveTreeseedTenantRoot(), getTreeseedAgentProviderSelections());
-  const 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 {
-  getTenantAgentHandlerModulePaths,
-  listRegisteredAgentHandlers,
-  loadTenantAgentHandlerRegistry,
-  resolveAgentHandler
-};

package/dist/agents/runtime-types.d.ts

@@ -1,118 +0,0 @@
-import type { AgentHandlerKind, AgentRuntimeSpec, AgentRunStatus, AgentTriggerConfig } from '@treeseed/sdk/types/agents';
-import type { AgentErrorCategory } from './contracts/run.ts';
-import type { ScopedAgentSdk } from '@treeseed/sdk/sdk';
-import type { SdkMessageEntity } from '@treeseed/sdk/types';
-export interface AgentTriggerInvocation {
-    kind: 'startup' | 'schedule' | 'message' | 'manual' | 'follow';
-    source: string;
-    trigger: AgentTriggerConfig;
-    message?: SdkMessageEntity | null;
-    followModels?: string[];
-    cursorValue?: string | null;
-}
-export interface AgentExecutionResult {
-    status: AgentRunStatus;
-    summary: string;
-    stdout?: string;
-    stderr?: string;
-    errorCategory?: AgentErrorCategory | null;
-    metadata?: Record<string, unknown>;
-}
-export interface AgentMutationResult {
-    branchName: string | null;
-    commitMessage: string | null;
-    worktreePath: string | null;
-    commitSha: string | null;
-    changedPaths: string[];
-}
-export interface AgentRepositoryInspectionResult {
-    branchName: string | null;
-    changedPaths: string[];
-    commitSha: string | null;
-    summary: string;
-}
-export interface AgentVerificationResult {
-    status: 'completed' | 'failed' | 'waiting';
-    summary: string;
-    stdout?: string;
-    stderr?: string;
-    errorCategory?: AgentErrorCategory | null;
-}
-export interface AgentNotificationResult {
-    status: 'completed' | 'failed' | 'waiting';
-    summary: string;
-    deliveredCount: number;
-}
-export interface AgentResearchResult {
-    status: 'completed' | 'failed' | 'waiting';
-    summary: string;
-    markdown: string;
-    sources?: string[];
-    errorCategory?: AgentErrorCategory | null;
-}
-export interface AgentExecutionAdapter {
-    runTask(input: {
-        agent: AgentRuntimeSpec;
-        runId: string;
-        prompt: string;
-    }): Promise<AgentExecutionResult>;
-}
-export interface AgentMutationAdapter {
-    writeArtifact(input: {
-        runId: string;
-        agent: AgentRuntimeSpec;
-        relativePath: string;
-        content: string;
-        commitMessage: string;
-    }): Promise<AgentMutationResult>;
-}
-export interface AgentRepositoryInspectionAdapter {
-    inspectBranch(input: {
-        repoRoot: string;
-        branchName: string | null;
-    }): Promise<AgentRepositoryInspectionResult>;
-}
-export interface AgentVerificationAdapter {
-    runChecks(input: {
-        agent: AgentRuntimeSpec;
-        runId: string;
-        commands: string[];
-    }): Promise<AgentVerificationResult>;
-}
-export interface AgentNotificationAdapter {
-    deliver(input: {
-        agent: AgentRuntimeSpec;
-        runId: string;
-        recipients: string[];
-        subject: string;
-        body: string;
-    }): Promise<AgentNotificationResult>;
-}
-export interface AgentResearchAdapter {
-    research(input: {
-        agent: AgentRuntimeSpec;
-        runId: string;
-        questionId: string;
-        reason: string | null;
-    }): Promise<AgentResearchResult>;
-}
-export interface AgentContext {
-    runId: string;
-    repoRoot: string;
-    agent: AgentRuntimeSpec;
-    sdk: ScopedAgentSdk;
-    trigger: AgentTriggerInvocation;
-    execution: AgentExecutionAdapter;
-    mutations: AgentMutationAdapter;
-    repository: AgentRepositoryInspectionAdapter;
-    verification: AgentVerificationAdapter;
-    notifications: AgentNotificationAdapter;
-    research: AgentResearchAdapter;
-}
-export interface AgentHandler<TInputs = unknown, TResult = unknown> {
-    kind: AgentHandlerKind;
-    resolveInputs(context: AgentContext): Promise<TInputs>;
-    execute(context: AgentContext, inputs: TInputs): Promise<TResult>;
-    emitOutputs(context: AgentContext, result: TResult): Promise<AgentExecutionResult>;
-}
-export {};

package/dist/agents/spec-loader.d.ts

@@ -1,18 +0,0 @@
-import type { AgentRuntimeSpec } from '@treeseed/sdk/types/agents';
-import { AgentSdk } from '@treeseed/sdk/sdk';
-import type { AgentSpecDiagnostic, NormalizedAgentRuntimeSpec } from './spec-types.ts';
-export interface AgentSpecLoadResult {
-    specs: NormalizedAgentRuntimeSpec[];
-    diagnostics: AgentSpecDiagnostic[];
-}
-export declare function loadAgentSpecs(sdk: AgentSdk, options?: {
-    enabled?: boolean;
-}): Promise<AgentSpecLoadResult>;
-export declare function loadActiveAgentSpecs(sdk: AgentSdk): Promise<AgentSpecLoadResult>;
-export declare function loadAllAgentSpecs(sdk: AgentSdk): Promise<AgentSpecLoadResult>;
-export declare function summarizeAgentSpec(agent: AgentRuntimeSpec): {
-    slug: string;
-    handler: string;
-    enabled: boolean;
-    triggers: ("startup" | "schedule" | "message" | "follow")[];
-};

package/dist/agents/spec-loader.js

@@ -1,55 +0,0 @@
-import { AgentSdk } from "@treeseed/sdk/sdk";
-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 registeredHandlers = await listRegisteredAgentHandlers();
-    const result = normalizeAgentRuntimeSpec(extractRawSpec(entry), {
-      registeredHandlers,
-      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.d.ts

@@ -1,2 +0,0 @@
-import type { AgentSpecNormalizationResult, AgentSpecValidationContext, RawAgentRuntimeSpec } from './spec-types.ts';
-export declare function normalizeAgentRuntimeSpec(raw: RawAgentRuntimeSpec, context: AgentSpecValidationContext): AgentSpecNormalizationResult;