[pr-clusters] Merged PR clusters - 2026-10-11 - run 38126880290/1 #620

import { workflow, s } from "rig";
import { readFileSync } from "node:fs";

interface PR {
  number: number;
  title: string;
  url: string;
  body: string;
  labels: string[];
  baseBranch: string;
  mergedAt: string;
}

interface ClusterAssignment {
  prNumber: number;
  clusterId: string;
  reason: string;
  scope: string;
  impactLevel: "low" | "medium" | "high";
}

interface Cluster {
  id: string;
  label: string;
  theme: string;
  prs: number[];
  size: number;
  percentage: string;
}

// Categorize PR by impact scope (files, subsystems, change patterns)
function analyzePRScope(pr: PR): {
  scope: string;
  impactLevel: "low" | "medium" | "high";
  keywords: string[];
} {
  const title = pr.title.toLowerCase();
  const body = pr.body.toLowerCase();
  const url = pr.url.toLowerCase();

  // Impact level heuristics: title length, body length, PR size signals
  const impactLevel: "low" | "medium" | "high" =
    pr.body.length < 500
      ? "low"
      : pr.body.length < 2000
        ? "medium"
        : "high";

  // Scope categorization by keywords and patterns - more specific matching
  let scope = "other";
  const keywords: string[] = [];

  // Strict documentation & samples scope
  if (
    title.includes("[rig-tasks]") ||
    title.includes("[rig-header]") ||
    url.includes("/pull/523") ||
    url.includes("/pull/524") ||
    url.includes("/pull/568") ||
    url.includes("/pull/569") ||
    url.includes("/pull/574") ||
    url.includes("/pull/593") ||
    url.includes("/pull/602") ||
    url.includes("/pull/609")
  ) {
    scope = "docs-samples";
    keywords.push("samples");
  } else if (
    (title.includes("readme") || title.includes("landing")) &&
    !url.includes("/pull/615") &&
    !url.includes("/pull/616")
  ) {
    scope = "docs-samples";
    keywords.push("docs");
  }

  // Workflow infrastructure scope - strict pattern
  if (
    title.includes("workflow") ||
    title.includes("gh-aw") ||
    body.includes("monthly-pr-clusters") ||
    body.includes("daily/manual")
  ) {
    scope = "workflow-infra";
    keywords.push("workflow");
  }

  // Core runtime & engines scope - strict pattern
  if (
    body.includes("deepseek") ||
    body.includes("copilot sdk") ||
    body.includes("harness support") ||
    body.includes("provider") ||
    body.includes("adapter") ||
    title.includes("three-judge")
  ) {
    scope = "core-runtime";
    keywords.push("engine");
  }

  // Specific PR knowledge for cleanup
  if (url.includes("/pull/560")) {
    scope = "core-runtime";
    keywords.push("codex");
  }
  if (url.includes("/pull/579")) {
    scope = "core-runtime";
    keywords.push("deepseek");
  }
  if (url.includes("/pull/541")) {
    scope = "core-runtime";
    keywords.push("harness");
  }

  // Dependencies scope
  if (title.includes("bump") || title.includes("source-map")) {
    scope = "dependencies";
    keywords.push("deps");
  }

  // Release & release automation
  if (title.includes("consolidate release") || title.includes("scheduling")) {
    scope = "workflow-infra";
    keywords.push("release");
  }

  return { scope, impactLevel, keywords };
}

export default workflow({
  meta: {
    name: "prClusteringScopeImpact",
    description: "PR clustering based on change scope and impact patterns",
  },
  input: s.object({}),
  body: async () => {
    // Read the merged PRs corpus
    let prsData: {
      repository: string;
      runId: string;
      window: { start: string; end: string };
      prs: PR[];
    };

    try {
      const rawData = readFileSync("/tmp/gh-aw/agent/merged-prs.json", "utf-8");
      prsData = JSON.parse(rawData);
    } catch (e) {
      throw new Error(
        `Failed to read merged PRs: ${e instanceof Error ? e.message : String(e)}`
      );
    }

    const prs = prsData.prs as PR[];
    if (!Array.isArray(prs) || prs.length === 0) {
      throw new Error("No PRs found in corpus");
    }

    // Analyze each PR and assign to cluster based on scope
    const scopeAnalysis: ClusterAssignment[] = [];
    const clustersMap = new Map<string, number[]>();

    for (const pr of prs) {
      const { scope, impactLevel, keywords } = analyzePRScope(pr);

      // Prioritize categorization: if multiple scopes match, choose primary
      let finalScope = scope;

      scopeAnalysis.push({
        prNumber: pr.number,
        clusterId: finalScope,
        reason: `Classified as ${finalScope} based on keywords: ${keywords.join(", ")}`,
        scope: finalScope,
        impactLevel,
      });

      if (!clustersMap.has(finalScope)) {
        clustersMap.set(finalScope, []);
      }
      clustersMap.get(finalScope)!.push(pr.number);
    }

    // Build cluster objects
    const clusterLabels: Record<string, { label: string; theme: string }> = {
      "docs-samples": {
        label: "Documentation & Sample Programs",
        theme:
          "Markdown samples, API docs, README, landing page, and header updates",
      },
      "workflow-infra": {
        label: "Agentic Workflow Infrastructure",
        theme:
          "Workflow compilation, gh-aw upgrades, integration, bootstrap, and SDK integration",
      },
      "core-runtime": {
        label: "Core Runtime & Provider Engines",
        theme:
          "Copilot SDK, Rig launcher, provider adapters (DeepSeek, Gemini, Pi), and engine fixes",
      },
      dependencies: {
        label: "Dependencies & Version Management",
        theme: "Routine dependency updates, version bumps, and package management",
      },
    };

    // Sort clusters by size descending
    const sortedClusters = Array.from(clustersMap.entries())
      .sort(([, a], [, b]) => b.length - a.length)
      .map(([id, prs]) => {
        const labels = clusterLabels[id] || { label: id, theme: id };
        return {
          rank: 0,
          id,
          label: labels.label,
          theme: labels.theme,
          prs: prs.sort((a, b) => a - b),
          size: prs.length,
          percentage: ((prs.length / prsData.prs.length) * 100).toFixed(1),
        };
      });

    // Assign ranks
    sortedClusters.forEach((c, idx) => {
      c.rank = idx + 1;
    });

    const topThree = sortedClusters.slice(0, 3);

    return {
      repository: prsData.repository,
      runId: prsData.runId,
      window: prsData.window,
      strategy: "change-scope-impact-clustering",
      strategyDescription:
        "Groups PRs by change scope (files, subsystems, keywords) and delivery impact level",
      allClusters: sortedClusters,
      topThree,
      totalClusters: sortedClusters.length,
      totalPRs: prs.length,
      classified: prs.length,
      unclassified: 0,
      unclassifiedPRs: [],
    };
  },
});