The Case for a Layered Event Matcher

HTTP POST → parseEvent() → WebhookEvent → matchPipelines() → assembleContext() → executePipeline()

// pipeline.ts:55–67
const triggers: string[] = pipeline.trigger[source] ?? [];
if (triggers.some((t) => event.event === t || event.event.startsWith(t + "."))) {
  matches.push([name, pipeline]);
}

async function gatherGitHistory(_event: WebhookEvent): Promise<string | null> {
  // TODO: use git log on the affected files
  return null;
}
 
async function gatherRelatedPRs(_event: WebhookEvent): Promise<string | null> {
  // TODO: query GitHub API for related PRs
  return null;
}

// context.ts:60–76
function formatEvent(event: WebhookEvent): string {
  if (event.source === "github") {
    const pr = payload.pull_request as Record<string, unknown>;
    // ...
  }
}

Layer 1: Domain Adapter     — HTTP → normalized WebhookEvent (exists)
Layer 2: Event Classifier   — WebhookEvent → typed ClassifiedEvent<T>
Layer 3: Project Router     — ClassifiedEvent → ProjectContext
Layer 4: Pipeline Matcher   — event + project → [MatchedPipeline]
Layer 5: Context Builder    — event + project + pipeline → EnrichedContext
Layer 6: Executor           — agent + prompt + context → spawn (exists)

// packages/core/src/classifier.ts
 
export type EventDomain = 'github' | 'linear' | 'slack' | 'generic';
 
export type GitHubEventType =
  | 'pull_request'
  | 'push'
  | 'issue'
  | 'issue_comment'
  | 'pull_request_review'
  | 'check_run'
  | 'deployment';
 
export type LinearEventType = 'Issue' | 'Comment' | 'Project' | 'Cycle';
 
// Typed, normalized GitHub PR payload — no more Record<string, unknown> casting
export interface GitHubPRData {
  number: number;
  title: string;
  url: string;
  author: string;
  authorType: 'user' | 'bot';     // detect dependabot, renovate, etc.
  base: string;
  head: string;
  body: string;
  draft: boolean;
  labels: string[];
  repoFullName: string;           // 'acme/frontend' — the critical routing key
  repoDefaultBranch: string;
  installationId?: string;        // for per-repo GitHub App auth
  orgLogin: string;               // 'acme'
}
 
export interface GitHubPushData {
  repoFullName: string;
  ref: string;
  branch: string;
  pusher: string;
  commitCount: number;
  compareUrl: string;
  installationId?: string;
}
 
export interface LinearIssueData {
  id: string;
  title: string;
  description: string;
  teamKey: string;                // 'HAR' — the critical routing key
  projectId?: string;
  priority: number;
  assigneeId?: string;
  workspaceId: string;
}
 
export interface ClassifiedEvent<T = unknown> {
  raw: WebhookEvent;              // always available for fallback
  domain: EventDomain;
  type: string;                   // 'pull_request', 'Issue', etc.
  action: string;                 // 'opened', 'create', 'synchronize'
  qualifiedName: string;          // 'pull_request.opened' — the current event string
  data: T;                        // typed normalized payload
  receivedAt: Date;
}
 
export interface EventClassifier {
  /**
   * Classify a raw webhook event into a typed, normalized form.
   * Returns null if the event is unrecognized or malformed.
   */
  classify(event: WebhookEvent): ClassifiedEvent | null;
}

// packages/core/src/project.ts
 
export interface ProjectContext {
  // Identity
  domain: EventDomain;
  org?: string;                   // 'acme'
  repo?: string;                  // 'frontend'
  repoFullName?: string;          // 'acme/frontend'
  repoCloneUrl?: string;          // for git operations in context builder
  defaultBranch?: string;
 
  // Linear
  teamKey?: string;               // 'HAR'
  linearWorkspaceId?: string;
 
  // Auth
  installationId?: string;        // GitHub App installation for this repo
  tokenRef?: string;              // secret reference for API calls
 
  // Metadata
  tags?: string[];                // inherited from bento.yaml project config
}
 
export interface ProjectRouter {
  /**
   * Extract project scope from a classified event.
   * Never throws — returns a partial context if info is unavailable.
   */
  extractProject(event: ClassifiedEvent): ProjectContext;
}

// services/daemon/src/matcher.ts
 
// Extended trigger config (backwards compatible)
export interface PipelineTriggerFilter {
  repos?: string[];               // ['acme/frontend', 'acme/*'] — glob patterns
  branches?: string[];            // ['main', 'release/*']
  authors?: string[];             // ['!dependabot[bot]'] — '!' prefix = exclude
  labels?: string[];              // PR must have at least one of these
  draft?: boolean;                // true = only drafts, false = only non-drafts
  teams?: string[];               // Linear team keys: ['HAR', 'ENG']
}
 
// This extends PipelineConfig.trigger — no breaking change
export interface PipelineTriggerV2 extends PipelineTrigger {
  filter?: PipelineTriggerFilter;
}
 
export interface MatchedPipeline {
  name: string;
  config: PipelineConfig;
  agent: DiscoveredAgent;         // resolved here — executor never looks up by name again
  project: ProjectContext;
  matchScore: number;             // higher = more specific match (repo-filter beats no-filter)
}
 
export interface PipelineMatcher {
  /**
   * Find all pipelines that match this event and project context.
   * Returns matches sorted by specificity (most specific first).
   */
  match(
    event: ClassifiedEvent,
    project: ProjectContext,
    pipelines: Record<string, PipelineConfig>,
    agents: Map<string, DiscoveredAgent>,
  ): MatchedPipeline[];
}

// services/daemon/src/context.ts (enhanced)
 
export interface ContextBuilderOptions {
  pipeline: PipelineConfig;
  event: ClassifiedEvent;
  project: ProjectContext;
  logger: Logger;
}
 
export interface EnrichedContext {
  // Existing
  summary: string;
  sections: ContextSection[];
 
  // New — available to executor for prompt rendering
  project: ProjectContext;
 
  // Structured event data for typed template vars (not just payload paths)
  eventData: Record<string, unknown>;
}
 
export interface ContextBuilder {
  /**
   * Assemble context for a pipeline run.
   * Receives typed event + project — no payload-parsing needed here.
   */
  assemble(options: ContextBuilderOptions): Promise<EnrichedContext>;
}

async function gatherGitHistory(
  event: ClassifiedEvent<GitHubPRData>,
  project: ProjectContext,
): Promise<string | null> {
  if (!project.repoCloneUrl) return null;
  const token = await resolveInstallationToken(project.installationId);
  // git log --oneline -20 HEAD..event.data.head
  // now actually implementable
}

pipelines:
  # Catches all PRs — low specificity
  pr-review-default:
    trigger:
      github: [pull_request.opened, pull_request.synchronize]
    agent: reviewer
    prompt: "Review this PR..."
 
  # Catches only payments/ PRs — higher specificity, wins over default
  pr-review-payments:
    trigger:
      github: [pull_request.opened, pull_request.synchronize]
      filter:
        repos: ['acme/payments']
        branches: ['main']
    agent: security-reviewer      # different agent
    prompt: "Review this payment-service PR with security focus..."
 
  # Only non-bot PRs on frontend, targeting main
  pr-review-frontend:
    trigger:
      github: [pull_request.opened]
      filter:
        repos: ['acme/frontend']
        authors: ['!dependabot[bot]', '!renovate[bot]']
        draft: false
    agent: reviewer
    context:
      git_history: true           # now actually works via ProjectContext