@mastra/factory 0.0.0 → 0.1.0-alpha.2

package/dist/rules/index.js

@@ -0,0 +1,577 @@
+// src/rules/types.ts
+var FACTORY_RULE_STAGES = ["intake", "triage", "planning", "execute", "review", "done", "canceled"];
+var FACTORY_RULE_BOARDS = ["work", "review"];
+var FACTORY_RULE_SOURCES = ["issue", "pullRequest", "linearIssue", "manual"];
+var FACTORY_GITHUB_EVENTS = [
+  "issueOpened",
+  "pullRequestOpened",
+  "pullRequestUpdated",
+  "pullRequestReviewRequested",
+  "pullRequestMerged"
+];
+var FACTORY_LINEAR_EVENTS = ["issueObserved"];
+function factoryRuleSourceForWorkItem(source) {
+  switch (source) {
+    case "github-issue":
+      return "issue";
+    case "github-pr":
+      return "pullRequest";
+    case "linear-issue":
+      return "linearIssue";
+    case "manual":
+      return "manual";
+  }
+}
+
+// src/rules/validation.ts
+var MAX_FACTORY_RULE_CAUSAL_DEPTH = 8;
+var MAX_VERSION_LENGTH = 128;
+var MAX_IDEMPOTENCY_KEY_LENGTH = 256;
+var MAX_REASON_LENGTH = 512;
+var MAX_TITLE_LENGTH = 512;
+var MAX_MESSAGE_LENGTH = 8192;
+var MAX_ARGUMENTS_LENGTH = 4096;
+var MAX_ROLE_LENGTH = 32;
+var MAX_SKILL_NAME_LENGTH = 128;
+var MAX_SOURCE_KEY_LENGTH = 256;
+var MAX_URL_LENGTH = 2048;
+var MAX_METADATA_JSON_LENGTH = 16384;
+var MAX_JSON_DEPTH = 8;
+var MAX_JSON_COLLECTION_SIZE = 100;
+var IDENTIFIER_RE = /^[a-z0-9][a-z0-9_-]*$/i;
+var SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var SENSITIVE_KEY_RE = /(?:authorization|cookie|credential|password|secret|token)/i;
+var WORK_ITEM_SOURCES = ["github-issue", "github-pr", "linear-issue", "manual"];
+var REJECTION_CODES = [
+  "forbidden",
+  "invalid_transition",
+  "missing_binding",
+  "stale",
+  "timeout",
+  "rule_error",
+  "causal_depth_exceeded",
+  "repeated_transition"
+];
+var FactoryRuleValidationError = class extends Error {
+  code = "invalid_factory_rule";
+  constructor(message) {
+    super(message);
+    this.name = "FactoryRuleValidationError";
+  }
+};
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function assertExactKeys(value, keys, label) {
+  const allowed = new Set(keys);
+  if (Object.keys(value).some((key) => !allowed.has(key))) {
+    throw new FactoryRuleValidationError(`${label} contains an unsupported field.`);
+  }
+}
+function boundedString(value, label, max, pattern) {
+  if (typeof value !== "string") throw new FactoryRuleValidationError(`${label} must be a string.`);
+  const normalized = value.trim();
+  if (normalized.length === 0 || normalized.length > max || pattern && !pattern.test(normalized)) {
+    throw new FactoryRuleValidationError(`${label} is invalid.`);
+  }
+  return normalized;
+}
+function optionalBoundedString(value, label, max) {
+  if (value === void 0) return void 0;
+  return boundedString(value, label, max);
+}
+function enumValue(value, allowed, label) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new FactoryRuleValidationError(`${label} is invalid.`);
+  }
+  return value;
+}
+function normalizeFactoryRuleJsonValue(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new FactoryRuleValidationError("Rule metadata must contain finite numbers.");
+    return value;
+  }
+  if (depth >= MAX_JSON_DEPTH || typeof value !== "object" && !Array.isArray(value)) {
+    throw new FactoryRuleValidationError("Rule metadata is not bounded JSON.");
+  }
+  if (seen.has(value)) throw new FactoryRuleValidationError("Rule metadata must not contain cycles.");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (value.length > MAX_JSON_COLLECTION_SIZE) {
+        throw new FactoryRuleValidationError("Rule metadata contains too many entries.");
+      }
+      return value.map((entry) => normalizeFactoryRuleJsonValue(entry, depth + 1, seen));
+    }
+    if (!isPlainObject(value)) throw new FactoryRuleValidationError("Rule metadata must use plain objects.");
+    const entries = Object.entries(value);
+    if (entries.length > MAX_JSON_COLLECTION_SIZE) {
+      throw new FactoryRuleValidationError("Rule metadata contains too many fields.");
+    }
+    const sanitized = {};
+    for (const [key, entry] of entries) {
+      const normalizedKey = boundedString(key, "Rule metadata key", 128, IDENTIFIER_RE);
+      sanitized[normalizedKey] = SENSITIVE_KEY_RE.test(normalizedKey) ? "[REDACTED]" : normalizeFactoryRuleJsonValue(entry, depth + 1, seen);
+    }
+    return sanitized;
+  } finally {
+    seen.delete(value);
+  }
+}
+function sanitizeMetadata(value) {
+  if (value === void 0) return void 0;
+  const sanitized = normalizeFactoryRuleJsonValue(value);
+  if (!isPlainObject(sanitized)) throw new FactoryRuleValidationError("Rule metadata must be an object.");
+  if (JSON.stringify(sanitized).length > MAX_METADATA_JSON_LENGTH) {
+    throw new FactoryRuleValidationError("Rule metadata is too large.");
+  }
+  return sanitized;
+}
+function validateBoardRules(rules, label) {
+  if (!isPlainObject(rules)) throw new FactoryRuleValidationError(`${label} must be an object.`);
+  for (const [stage, sources] of Object.entries(rules)) {
+    enumValue(stage, FACTORY_RULE_STAGES, `${label} stage`);
+    if (!isPlainObject(sources)) throw new FactoryRuleValidationError(`${label}.${stage} must be an object.`);
+    for (const [source, leaf] of Object.entries(sources)) {
+      enumValue(source, FACTORY_RULE_SOURCES, `${label}.${stage} source`);
+      if (!isPlainObject(leaf)) throw new FactoryRuleValidationError(`${label}.${stage}.${source} must be an object.`);
+      assertExactKeys(leaf, ["onEnter", "onExit"], `${label}.${stage}.${source}`);
+      for (const handler of Object.values(leaf)) {
+        if (handler !== void 0 && typeof handler !== "function") {
+          throw new FactoryRuleValidationError(`${label}.${stage}.${source} handlers must be functions.`);
+        }
+      }
+    }
+  }
+}
+function assertFactoryRules(rules) {
+  if (!isPlainObject(rules)) throw new FactoryRuleValidationError("Factory rules must be an object.");
+  assertExactKeys(rules, ["version", "work", "review", "tools", "github", "linear"], "Factory rules");
+  boundedString(rules.version, "Factory rule version", MAX_VERSION_LENGTH);
+  validateBoardRules(rules.work, "Factory rules.work");
+  validateBoardRules(rules.review, "Factory rules.review");
+  if (!isPlainObject(rules.tools)) throw new FactoryRuleValidationError("Factory rules.tools must be an object.");
+  for (const [toolName, leaf] of Object.entries(rules.tools)) {
+    boundedString(toolName, "Factory tool name", 128, IDENTIFIER_RE);
+    if (!isPlainObject(leaf))
+      throw new FactoryRuleValidationError(`Factory rules.tools.${toolName} must be an object.`);
+    assertExactKeys(leaf, ["onResult"], `Factory rules.tools.${toolName}`);
+    if (leaf.onResult !== void 0 && typeof leaf.onResult !== "function") {
+      throw new FactoryRuleValidationError(`Factory rules.tools.${toolName}.onResult must be a function.`);
+    }
+  }
+  if (!isPlainObject(rules.github)) throw new FactoryRuleValidationError("Factory rules.github must be an object.");
+  for (const [event, leaf] of Object.entries(rules.github)) {
+    enumValue(event, FACTORY_GITHUB_EVENTS, "Factory GitHub event");
+    if (!isPlainObject(leaf)) throw new FactoryRuleValidationError(`Factory rules.github.${event} must be an object.`);
+    assertExactKeys(leaf, ["onEvent"], `Factory rules.github.${event}`);
+    if (leaf.onEvent !== void 0 && typeof leaf.onEvent !== "function") {
+      throw new FactoryRuleValidationError(`Factory rules.github.${event}.onEvent must be a function.`);
+    }
+  }
+  if (!isPlainObject(rules.linear)) throw new FactoryRuleValidationError("Factory rules.linear must be an object.");
+  for (const [event, leaf] of Object.entries(rules.linear)) {
+    enumValue(event, FACTORY_LINEAR_EVENTS, "Factory Linear event");
+    if (!isPlainObject(leaf)) throw new FactoryRuleValidationError(`Factory rules.linear.${event} must be an object.`);
+    assertExactKeys(leaf, ["onEvent"], `Factory rules.linear.${event}`);
+    if (leaf.onEvent !== void 0 && typeof leaf.onEvent !== "function") {
+      throw new FactoryRuleValidationError(`Factory rules.linear.${event}.onEvent must be a function.`);
+    }
+  }
+}
+function commonCommitFields(value) {
+  return {
+    idempotencyKey: boundedString(value.idempotencyKey, "Factory decision idempotencyKey", MAX_IDEMPOTENCY_KEY_LENGTH)
+  };
+}
+function validateFactoryRuleDecision(value, causalDepth = 0) {
+  if (causalDepth > MAX_FACTORY_RULE_CAUSAL_DEPTH) {
+    throw new FactoryRuleValidationError("Factory rule causal depth exceeded.");
+  }
+  if (!isPlainObject(value)) throw new FactoryRuleValidationError("Factory rule decision must be an object.");
+  const type = value.type;
+  if (typeof type !== "string") throw new FactoryRuleValidationError("Factory rule decision type is required.");
+  switch (type) {
+    case "reject": {
+      assertExactKeys(value, ["type", "code", "reason"], "Factory reject decision");
+      return {
+        type,
+        code: enumValue(value.code, REJECTION_CODES, "Factory rejection code"),
+        reason: boundedString(value.reason, "Factory rejection reason", MAX_REASON_LENGTH)
+      };
+    }
+    case "transition": {
+      assertExactKeys(value, ["type", "idempotencyKey", "board", "stage"], "Factory transition decision");
+      return {
+        type,
+        ...commonCommitFields(value),
+        board: enumValue(value.board, FACTORY_RULE_BOARDS, "Factory transition board"),
+        stage: enumValue(value.stage, FACTORY_RULE_STAGES, "Factory transition stage")
+      };
+    }
+    case "upsertLinkedWorkItem": {
+      assertExactKeys(
+        value,
+        ["type", "idempotencyKey", "board", "source", "sourceKey", "title", "url", "stage", "metadata"],
+        "Factory linked work item decision"
+      );
+      const url = value.url;
+      if (url !== null && (typeof url !== "string" || url.length > MAX_URL_LENGTH || !/^https?:\/\//.test(url))) {
+        throw new FactoryRuleValidationError("Factory linked work item URL is invalid.");
+      }
+      const metadata = sanitizeMetadata(value.metadata);
+      return {
+        type,
+        ...commonCommitFields(value),
+        board: enumValue(value.board, FACTORY_RULE_BOARDS, "Factory linked work item board"),
+        source: enumValue(value.source, WORK_ITEM_SOURCES, "Factory linked work item source"),
+        sourceKey: boundedString(value.sourceKey, "Factory linked work item sourceKey", MAX_SOURCE_KEY_LENGTH),
+        title: boundedString(value.title, "Factory linked work item title", MAX_TITLE_LENGTH),
+        url,
+        stage: enumValue(value.stage, FACTORY_RULE_STAGES, "Factory linked work item stage"),
+        ...metadata ? { metadata } : {}
+      };
+    }
+    case "invokeSkill": {
+      assertExactKeys(
+        value,
+        ["type", "idempotencyKey", "role", "skillName", "arguments", "precedingMessage"],
+        "Factory invoke skill decision"
+      );
+      const args = optionalBoundedString(value.arguments, "Factory skill arguments", MAX_ARGUMENTS_LENGTH);
+      const precedingMessage = optionalBoundedString(
+        value.precedingMessage,
+        "Factory skill preceding message",
+        MAX_MESSAGE_LENGTH
+      );
+      return {
+        type,
+        ...commonCommitFields(value),
+        role: boundedString(value.role, "Factory skill role", MAX_ROLE_LENGTH, IDENTIFIER_RE),
+        skillName: boundedString(value.skillName, "Factory skill name", MAX_SKILL_NAME_LENGTH, SKILL_NAME_RE),
+        ...args ? { arguments: args } : {},
+        ...precedingMessage ? { precedingMessage } : {}
+      };
+    }
+    case "sendMessage": {
+      assertExactKeys(
+        value,
+        ["type", "idempotencyKey", "role", "message", "priority", "idleBehavior", "prepareBinding"],
+        "Factory send message decision"
+      );
+      const priority = value.priority === void 0 ? void 0 : enumValue(value.priority, ["medium", "high", "urgent"], "Factory message priority");
+      const idleBehavior = value.idleBehavior === void 0 ? void 0 : enumValue(value.idleBehavior, ["persist", "wake"], "Factory message idle behavior");
+      if (value.prepareBinding !== void 0 && typeof value.prepareBinding !== "boolean") {
+        throw new FactoryRuleValidationError("Factory message prepareBinding must be a boolean.");
+      }
+      return {
+        type,
+        ...commonCommitFields(value),
+        role: boundedString(value.role, "Factory message role", MAX_ROLE_LENGTH, IDENTIFIER_RE),
+        message: boundedString(value.message, "Factory message", MAX_MESSAGE_LENGTH),
+        ...priority ? { priority } : {},
+        ...idleBehavior ? { idleBehavior } : {},
+        ...value.prepareBinding === true ? { prepareBinding: true } : {}
+      };
+    }
+    case "notify": {
+      assertExactKeys(value, ["type", "idempotencyKey", "title", "body", "level"], "Factory notify decision");
+      const body = optionalBoundedString(value.body, "Factory notification body", MAX_MESSAGE_LENGTH);
+      const level = value.level === void 0 ? void 0 : enumValue(value.level, ["info", "warning", "error"], "Factory notification level");
+      return {
+        type,
+        ...commonCommitFields(value),
+        title: boundedString(value.title, "Factory notification title", MAX_TITLE_LENGTH),
+        ...body ? { body } : {},
+        ...level ? { level } : {}
+      };
+    }
+    default:
+      throw new FactoryRuleValidationError("Factory rule decision type is unsupported.");
+  }
+}
+function validateFactoryRuleDecisions(values, causalDepth = 0) {
+  if (values.length > MAX_JSON_COLLECTION_SIZE) {
+    throw new FactoryRuleValidationError("Factory rule produced too many decisions.");
+  }
+  const decisions = [];
+  for (const value of values) {
+    const decision = validateFactoryRuleDecision(value, causalDepth);
+    if (decision.type === "reject") {
+      throw new FactoryRuleValidationError("A rejection cannot be persisted with commit decisions.");
+    }
+    decisions.push(decision);
+  }
+  const keys = decisions.map((decision) => decision.idempotencyKey);
+  if (new Set(keys).size !== keys.length) {
+    throw new FactoryRuleValidationError("Factory decisions require unique idempotency keys.");
+  }
+  return decisions;
+}
+
+// src/rules/defaults.ts
+var DEFAULT_FACTORY_RULE_VERSION = "factory-default-v1";
+function trustedGithubActor(context) {
+  return context.actor.type === "github" && context.actor.trusted;
+}
+function invokeIssueInvestigation(context) {
+  return {
+    type: "invokeSkill",
+    idempotencyKey: `${context.ingress.id}:understand-issue`,
+    role: "triage",
+    skillName: "understand-issue",
+    arguments: context.item.url ? `GitHub issue (${context.item.url})` : context.item.title
+  };
+}
+function investigateTriagedIssue(context) {
+  return invokeIssueInvestigation(context);
+}
+function investigateTriagedLinearIssue(context) {
+  const identifier = context.item.sourceKey?.startsWith("linear:") ? context.item.sourceKey.slice("linear:".length) : context.item.title;
+  return {
+    type: "invokeSkill",
+    idempotencyKey: `${context.ingress.id}:understand-linear-issue`,
+    role: "triage",
+    skillName: "understand-issue",
+    arguments: `Linear issue ${identifier}${context.item.url ? ` (${context.item.url})` : ""}`
+  };
+}
+function reviewPullRequest(context) {
+  return {
+    type: "invokeSkill",
+    idempotencyKey: `${context.ingress.id}:understand-pr`,
+    role: "review",
+    skillName: "understand-pr",
+    arguments: context.item.url ? `GitHub pull request (${context.item.url})` : context.item.title
+  };
+}
+function resultContent(value) {
+  if (typeof value === "string") return value;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return;
+  const content = value.content;
+  return typeof content === "string" ? content : void 0;
+}
+function advanceApprovedPlan(context) {
+  if (context.result.status !== "success" || context.board !== "work" || context.item.stages.length !== 1 || context.item.stages[0] !== "planning" || context.actor.type !== "agent" || context.actor.role !== "plan" || !resultContent(context.result.value)?.startsWith("Plan approved.")) {
+    return;
+  }
+  return {
+    type: "transition",
+    idempotencyKey: `${context.ingress.id}:approved-plan`,
+    board: "work",
+    stage: "execute"
+  };
+}
+function issueOpened(context) {
+  if (!context.issue) return;
+  return {
+    type: "upsertLinkedWorkItem",
+    idempotencyKey: `${context.ingress.id}:issue-intake`,
+    board: "work",
+    source: "github-issue",
+    sourceKey: `github-issue:${context.issue.number}`,
+    title: context.issue.title,
+    url: context.issue.url,
+    stage: trustedGithubActor(context) ? "triage" : "intake",
+    metadata: {
+      githubRepositoryId: context.repository.id,
+      githubIssueNumber: context.issue.number
+    }
+  };
+}
+function pullRequestOpened(context) {
+  if (!context.pullRequest) return;
+  return {
+    type: "upsertLinkedWorkItem",
+    idempotencyKey: `${context.ingress.id}:pull-request-intake`,
+    board: "review",
+    source: "github-pr",
+    sourceKey: `github-pr:${context.pullRequest.number}`,
+    title: context.pullRequest.title,
+    url: context.pullRequest.url,
+    stage: trustedGithubActor(context) ? "review" : "intake",
+    metadata: {
+      githubRepositoryId: context.repository.id,
+      githubPullRequestNumber: context.pullRequest.number,
+      factoryAuthored: context.actor.type === "github" && context.actor.factoryAuthored
+    }
+  };
+}
+function pullRequestMerged(context) {
+  if (!context.item || !context.pullRequest?.merged) return;
+  return {
+    type: "sendMessage",
+    idempotencyKey: `${context.ingress.id}:assess-work-completion`,
+    role: "work",
+    message: `Pull request #${context.pullRequest.number} merged. Assess whether the linked Work item is complete. Do not mark it Done solely because this PR merged; use factory_transition_work_item only after verifying the work.`
+  };
+}
+function linearIssueObserved(context) {
+  if (context.item) return;
+  return {
+    type: "upsertLinkedWorkItem",
+    idempotencyKey: `${context.ingress.id}:issue-triage`,
+    board: "work",
+    source: "linear-issue",
+    sourceKey: `linear:${context.issue.identifier}`,
+    title: `${context.issue.identifier}: ${context.issue.title}`,
+    url: context.issue.url,
+    stage: "triage",
+    metadata: {
+      linearIssueId: context.issue.id,
+      linearIssueIdentifier: context.issue.identifier,
+      linearState: context.issue.state,
+      linearStateType: context.issue.stateType,
+      linearPriority: context.issue.priorityLabel,
+      linearAssignee: context.issue.assignee,
+      linearTeam: context.issue.team
+    }
+  };
+}
+var BUILT_IN_DEFAULTS = {
+  work: {
+    triage: {
+      issue: { onEnter: investigateTriagedIssue },
+      linearIssue: { onEnter: investigateTriagedLinearIssue }
+    }
+  },
+  review: { review: { pullRequest: { onEnter: reviewPullRequest } } },
+  tools: { submit_plan: { onResult: advanceApprovedPlan } },
+  github: {
+    issueOpened: { onEvent: issueOpened },
+    pullRequestOpened: { onEvent: pullRequestOpened },
+    pullRequestMerged: { onEvent: pullRequestMerged }
+  },
+  linear: { issueObserved: { onEvent: linearIssueObserved } }
+};
+function mergeBoardRules(base, overrides) {
+  const result = {};
+  const stages = /* @__PURE__ */ new Set([...Object.keys(base ?? {}), ...Object.keys(overrides ?? {})]);
+  for (const stage of stages) {
+    const baseSources = base?.[stage];
+    const overrideSources = overrides?.[stage];
+    const sources = /* @__PURE__ */ new Set([
+      ...Object.keys(baseSources ?? {}),
+      ...Object.keys(overrideSources ?? {})
+    ]);
+    const mergedSources = {};
+    for (const source of sources) {
+      const baseLeaf = baseSources?.[source];
+      const overrideLeaf = overrideSources?.[source];
+      mergedSources[source] = {
+        ...baseLeaf?.onEnter ? { onEnter: baseLeaf.onEnter } : {},
+        ...baseLeaf?.onExit ? { onExit: baseLeaf.onExit } : {},
+        ...overrideLeaf && "onEnter" in overrideLeaf ? { onEnter: overrideLeaf.onEnter } : {},
+        ...overrideLeaf && "onExit" in overrideLeaf ? { onExit: overrideLeaf.onExit } : {}
+      };
+    }
+    result[stage] = mergedSources;
+  }
+  return result;
+}
+function mergeToolRules(base, overrides) {
+  const result = {};
+  for (const name of /* @__PURE__ */ new Set([...Object.keys(base ?? {}), ...Object.keys(overrides ?? {})])) {
+    const baseLeaf = base?.[name];
+    const overrideLeaf = overrides?.[name];
+    result[name] = {
+      ...baseLeaf?.onResult ? { onResult: baseLeaf.onResult } : {},
+      ...overrideLeaf && "onResult" in overrideLeaf ? { onResult: overrideLeaf.onResult } : {}
+    };
+  }
+  return result;
+}
+function mergeGithubRules(base, overrides) {
+  const result = {};
+  const events = /* @__PURE__ */ new Set([...Object.keys(base ?? {}), ...Object.keys(overrides ?? {})]);
+  for (const event of events) {
+    const baseLeaf = base?.[event];
+    const overrideLeaf = overrides?.[event];
+    result[event] = {
+      ...baseLeaf?.onEvent ? { onEvent: baseLeaf.onEvent } : {},
+      ...overrideLeaf && "onEvent" in overrideLeaf ? { onEvent: overrideLeaf.onEvent } : {}
+    };
+  }
+  return result;
+}
+function mergeLinearRules(base, overrides) {
+  const result = {};
+  const events = /* @__PURE__ */ new Set([...Object.keys(base ?? {}), ...Object.keys(overrides ?? {})]);
+  for (const event of events) {
+    const baseLeaf = base?.[event];
+    const overrideLeaf = overrides?.[event];
+    result[event] = {
+      ...baseLeaf?.onEvent ? { onEvent: baseLeaf.onEvent } : {},
+      ...overrideLeaf && "onEvent" in overrideLeaf ? { onEvent: overrideLeaf.onEvent } : {}
+    };
+  }
+  return result;
+}
+function mergeFactoryRuleOverrides(base, overrides = {}) {
+  return {
+    work: mergeBoardRules(base.work, overrides.work),
+    review: mergeBoardRules(base.review, overrides.review),
+    tools: mergeToolRules(base.tools, overrides.tools),
+    github: mergeGithubRules(base.github, overrides.github),
+    linear: mergeLinearRules(base.linear, overrides.linear)
+  };
+}
+function defaultFactoryRules(input) {
+  if (typeof input?.version !== "string" || input.version.trim().length === 0) {
+    throw new FactoryRuleValidationError("Factory rule version is required.");
+  }
+  const rules = {
+    version: input.version.trim(),
+    ...mergeFactoryRuleOverrides(BUILT_IN_DEFAULTS, input.overrides)
+  };
+  assertFactoryRules(rules);
+  return rules;
+}
+function builtInFactoryRules() {
+  return defaultFactoryRules({ version: DEFAULT_FACTORY_RULE_VERSION });
+}
+
+// src/rules/resolve.ts
+function resolveFactoryStageRules(rules, input) {
+  if (input.fromStage === input.toStage && !input.initialEntry) return [];
+  const boardRules = rules[input.board];
+  const resolved = [];
+  const onExit = input.initialEntry ? void 0 : boardRules[input.fromStage]?.[input.source]?.onExit;
+  if (onExit) resolved.push({ phase: "exit", handler: onExit });
+  const onEnter = boardRules[input.toStage]?.[input.source]?.onEnter;
+  if (onEnter) resolved.push({ phase: "enter", handler: onEnter });
+  return resolved;
+}
+function resolveFactoryToolRule(rules, toolName) {
+  return rules.tools[toolName]?.onResult;
+}
+function resolveFactoryGithubRule(rules, event) {
+  return rules.github[event]?.onEvent;
+}
+function resolveFactoryLinearRule(rules, event) {
+  return rules.linear[event]?.onEvent;
+}
+export {
+  DEFAULT_FACTORY_RULE_VERSION,
+  FACTORY_GITHUB_EVENTS,
+  FACTORY_LINEAR_EVENTS,
+  FACTORY_RULE_BOARDS,
+  FACTORY_RULE_SOURCES,
+  FACTORY_RULE_STAGES,
+  FactoryRuleValidationError,
+  MAX_FACTORY_RULE_CAUSAL_DEPTH,
+  assertFactoryRules,
+  builtInFactoryRules,
+  defaultFactoryRules,
+  factoryRuleSourceForWorkItem,
+  resolveFactoryGithubRule,
+  resolveFactoryLinearRule,
+  resolveFactoryStageRules,
+  resolveFactoryToolRule,
+  validateFactoryRuleDecision,
+  validateFactoryRuleDecisions
+};
+//# sourceMappingURL=index.js.map