@cursor/july 0.1.96 → 0.1.97

package/templates/agents-md/agent/lib/collect.ts

@@ -0,0 +1,439 @@
+import {
+  prompt,
+  type AuthContext,
+  type HostContext,
+  type SendMessageFn,
+} from "@cursor/july";
+import { REPOS, slackChannels } from "./config.js";
+import { isAgentsPath, isUpdateRef, snapshotPath } from "./paths.js";
+
+const LOOKBACK_DAYS = 7;
+const MAX_PRS = 50;
+const MAX_FILES = 40;
+const MAX_COMMENTS = 8;
+const MAX_BODY = 1_200;
+const MAX_SLACK = 80;
+const MAX_LINE = 400;
+const MAX_AGENTS = 20;
+const CHANNEL_ID = /^[CGD][A-Z0-9]{8,}$/i;
+
+type Octokit = Awaited<ReturnType<HostContext["github"]["getOctokit"]>>;
+type Slack = Awaited<ReturnType<HostContext["slack"]["getClient"]>>;
+
+type Pull = {
+  number: number;
+  title: string;
+  body: string;
+  author: string;
+  merged: string;
+  url: string;
+  files: string[];
+  comments: string[];
+};
+
+export type Week = {
+  window: string;
+  prompt: string;
+  files: Record<string, string>;
+};
+
+export async function collectWeek(host: HostContext): Promise<Week> {
+  const now = new Date();
+  const start = new Date(now.getTime() - LOOKBACK_DAYS * 86_400_000);
+  const until = isoDate(now);
+  const since = isoDate(start);
+  const window = `${since}/${until}`;
+  const repo = REPOS[0];
+  if (repo === undefined) {
+    throw new Error("REPOS is empty");
+  }
+  const files: Record<string, string> = {
+    "week/window.txt": `${window}\n`,
+    "week/repo.txt": `${repo}\n`,
+  };
+
+  const octokit = await host.github.getOctokit();
+  const parsed = splitRepo(repo);
+  const repoInfo = await octokit.rest.repos.get(parsed);
+  const base = repoInfo.data.default_branch;
+  files["week/base.ref"] = `${base}\n`;
+  const pulls = await loadPulls(octokit, parsed, since);
+  files["week/prs.md"] = formatPulls(pulls);
+  const agents = await loadAgents(octokit, parsed, base, pulls);
+  Object.assign(files, agents.files);
+  files["week/files.txt"] = `${agents.paths.join("\n")}\n`;
+  files["week/slack.md"] = await loadSlack(host, Math.floor(start.getTime() / 1000));
+
+  return {
+    window,
+    files,
+    prompt: prompt`
+      Weekly AGENTS.md review for ${repo} (${window}).
+      Read week/ and week/tree/. Call apply_agents once.
+    `,
+  };
+}
+
+export function startWeek(
+  send: SendMessageFn,
+  week: Week,
+  auth: AuthContext | null
+) {
+  return send(week.prompt, {
+    auth,
+    title: `AGENTS.md ${week.window}`,
+    continuationToken: `agents-md:${week.window}`,
+    admission: "coalesce",
+    workspaceFiles: week.files,
+  });
+}
+
+export function weekFromTarget(target: unknown): Week | undefined {
+  if (!isRecord(target)) {
+    return undefined;
+  }
+  if (typeof target.window !== "string" || typeof target.prompt !== "string") {
+    return undefined;
+  }
+  if (!isRecord(target.files)) {
+    return undefined;
+  }
+  const files: Record<string, string> = {};
+  for (const [path, content] of Object.entries(target.files)) {
+    if (typeof content !== "string") {
+      return undefined;
+    }
+    files[path] = content;
+  }
+  return { window: target.window, prompt: target.prompt, files };
+}
+
+async function loadPulls(
+  octokit: Octokit,
+  repo: { owner: string; repo: string },
+  since: string
+): Promise<Pull[]> {
+  const sinceMs = Date.parse(`${since}T00:00:00Z`);
+  let count = 0;
+  const closed = await octokit.paginate(
+    octokit.rest.pulls.list,
+    {
+      ...repo,
+      state: "closed",
+      sort: "updated",
+      direction: "desc",
+      per_page: 50,
+    },
+    (response, done) => {
+      const keep = [];
+      for (const pull of response.data) {
+        if (count + keep.length >= MAX_PRS) {
+          done();
+          break;
+        }
+        if (Date.parse(pull.updated_at) < sinceMs) {
+          done();
+          break;
+        }
+        if (pull.merged_at === null || Date.parse(pull.merged_at) < sinceMs) {
+          continue;
+        }
+        if (isUpdateRef(pull.head.ref)) {
+          continue;
+        }
+        keep.push(pull);
+      }
+      count += keep.length;
+      return keep;
+    }
+  );
+  const pulls: Pull[] = [];
+  for (const pull of closed) {
+    pulls.push(await loadPull(octokit, repo, pull));
+  }
+  return pulls;
+}
+
+async function loadPull(
+  octokit: Octokit,
+  repo: { owner: string; repo: string },
+  pull: {
+    number: number;
+    title: string;
+    body?: string | null;
+    user?: { login?: string } | null;
+    merged_at?: string | null;
+    html_url: string;
+  }
+): Promise<Pull> {
+  const args = { ...repo, pull_number: pull.number };
+  const [listed, issue, review] = await Promise.all([
+    octokit.rest.pulls.listFiles({ ...args, per_page: MAX_FILES }),
+    octokit.rest.issues.listComments({
+      ...repo,
+      issue_number: pull.number,
+      per_page: MAX_COMMENTS,
+    }),
+    octokit.rest.pulls.listReviewComments({
+      ...args,
+      per_page: MAX_COMMENTS,
+    }),
+  ]);
+  const comments = [...issue.data, ...review.data]
+    .map((item) => {
+      const author = item.user?.login ?? "unknown";
+      return `@${author}: ${clip(item.body ?? "", MAX_LINE)}`;
+    })
+    .filter((line) => !line.endsWith(": "));
+  return {
+    number: pull.number,
+    title: pull.title,
+    body: clip(pull.body ?? "", MAX_BODY),
+    author: pull.user?.login ?? "unknown",
+    merged: pull.merged_at ?? "",
+    url: pull.html_url,
+    files: listed.data.map((file) => file.filename),
+    comments,
+  };
+}
+
+async function loadAgents(
+  octokit: Octokit,
+  repo: { owner: string; repo: string },
+  ref: string,
+  pulls: Pull[]
+): Promise<{ paths: string[]; files: Record<string, string> }> {
+  const paths = new Set<string>(["AGENTS.md"]);
+  for (const path of await listAgents(octokit, repo, ref)) {
+    paths.add(path);
+  }
+  for (const pull of pulls) {
+    for (const file of pull.files) {
+      if (isAgentsPath(file)) {
+        paths.add(file);
+      }
+    }
+  }
+  const chosen = [...paths].slice(0, MAX_AGENTS);
+  const files: Record<string, string> = {};
+  const found: string[] = [];
+  for (const path of chosen) {
+    const body = await readFile(octokit, { ...repo, path, ref });
+    if (body !== undefined) {
+      found.push(path);
+      files[snapshotPath(path)] = body;
+    }
+  }
+  return { paths: found.sort(), files };
+}
+
+async function listAgents(
+  octokit: Octokit,
+  repo: { owner: string; repo: string },
+  ref: string
+): Promise<string[]> {
+  try {
+    const { data: refData } = await octokit.rest.git.getRef({
+      ...repo,
+      ref: `heads/${ref}`,
+    });
+    const { data } = await octokit.rest.git.getTree({
+      ...repo,
+      tree_sha: refData.object.sha,
+      recursive: "1",
+    });
+    return (data.tree ?? [])
+      .map((entry) => entry.path)
+      .filter(
+        (path): path is string =>
+          typeof path === "string" && isAgentsPath(path)
+      );
+  } catch (error) {
+    if (isNotFound(error)) {
+      return [];
+    }
+    throw error;
+  }
+}
+
+async function loadSlack(host: HostContext, oldest: number): Promise<string> {
+  const names = slackChannels();
+  if (names.length === 0) {
+    return "No Slack channels configured.\n";
+  }
+  let client: Slack;
+  try {
+    client = await host.slack.getClient();
+  } catch (error) {
+    return `Slack unavailable: ${errorMessage(error)}\n`;
+  }
+  const sections: string[] = [];
+  for (const name of names) {
+    sections.push(await readChannel(client, name, oldest));
+  }
+  return `${sections.join("\n")}\n`;
+}
+
+async function readChannel(
+  client: Slack,
+  name: string,
+  oldest: number
+): Promise<string> {
+  const id = await resolveChannel(client, name);
+  if (id === undefined) {
+    return `## ${name}\nUnresolved. Invite the bot and check the name.\n`;
+  }
+  let history: Awaited<ReturnType<Slack["conversations"]["history"]>>;
+  try {
+    history = await client.conversations.history({
+      channel: id,
+      oldest: String(oldest),
+      limit: MAX_SLACK,
+    });
+  } catch (error) {
+    return `## ${name}\n${errorMessage(error)}\n`;
+  }
+  const lines = [`## ${name}`];
+  for (const msg of history.messages ?? []) {
+    if (skipSlack(msg)) {
+      continue;
+    }
+    lines.push(`- ${formatSlack(msg)}`);
+    if ((msg.reply_count ?? 0) === 0 || msg.ts === undefined) {
+      continue;
+    }
+    const replies = await client.conversations.replies({
+      channel: id,
+      ts: msg.ts,
+      limit: 6,
+    });
+    for (const reply of (replies.messages ?? []).slice(1, 6)) {
+      if (skipSlack(reply)) {
+        continue;
+      }
+      lines.push(`  - ${formatSlack(reply)}`);
+    }
+  }
+  if (lines.length === 1) {
+    lines.push("No messages this week.");
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+async function resolveChannel(
+  client: Slack,
+  name: string
+): Promise<string | undefined> {
+  const trimmed = name.replace(/^#/, "");
+  if (CHANNEL_ID.test(trimmed)) {
+    return trimmed;
+  }
+  let cursor: string | undefined;
+  for (let page = 0; page < 4; page++) {
+    const listed = await client.users.conversations({
+      types: "public_channel,private_channel",
+      exclude_archived: true,
+      limit: 200,
+      cursor,
+    });
+    const match = listed.channels?.find((channel) => channel.name === trimmed);
+    if (match?.id !== undefined) {
+      return match.id;
+    }
+    cursor = listed.response_metadata?.next_cursor;
+    if (cursor === undefined || cursor === "") {
+      return undefined;
+    }
+  }
+  return undefined;
+}
+
+async function readFile(
+  octokit: Octokit,
+  args: { owner: string; repo: string; path: string; ref: string }
+): Promise<string | undefined> {
+  try {
+    const { data } = await octokit.rest.repos.getContent(args);
+    if (Array.isArray(data) || data.encoding !== "base64") {
+      return undefined;
+    }
+    if (typeof data.content !== "string") {
+      return undefined;
+    }
+    return Buffer.from(data.content, "base64").toString("utf8");
+  } catch (error) {
+    if (isNotFound(error)) {
+      return undefined;
+    }
+    throw error;
+  }
+}
+
+function formatPulls(pulls: Pull[]): string {
+  if (pulls.length === 0) {
+    return "No merged pull requests this week.\n";
+  }
+  return `${pulls.map(formatPull).join("\n")}\n`;
+}
+
+function formatPull(pull: Pull): string {
+  const comments =
+    pull.comments.length === 0
+      ? ""
+      : `\n\n### comments\n${pull.comments.map((line) => `- ${line}`).join("\n")}`;
+  return `## #${pull.number} ${pull.title}
+url: ${pull.url}
+author: @${pull.author}
+merged: ${pull.merged}
+files: ${pull.files.join(", ")}
+
+${pull.body}${comments}`;
+}
+
+function formatSlack(msg: { text?: string; user?: string; ts?: string }): string {
+  const who = msg.user === undefined ? "unknown" : `<@${msg.user}>`;
+  return `${who}: ${clip(msg.text ?? "", MAX_LINE)}`;
+}
+
+function skipSlack(msg: { subtype?: string; text?: string }): boolean {
+  if (msg.subtype !== undefined && msg.subtype !== "thread_broadcast") {
+    return true;
+  }
+  return (msg.text ?? "").trim() === "";
+}
+
+function splitRepo(fullName: string): { owner: string; repo: string } {
+  const [owner, repo] = fullName.split("/");
+  if (owner === undefined || repo === undefined) {
+    throw new Error(`invalid repo: ${fullName}`);
+  }
+  return { owner, repo };
+}
+
+function clip(text: string, max: number): string {
+  if (text.length <= max) {
+    return text;
+  }
+  return `${text.slice(0, max)}\n…[truncated]`;
+}
+
+function isoDate(value: Date): string {
+  return value.toISOString().slice(0, 10);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isNotFound(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "status" in error &&
+    error.status === 404
+  );
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/templates/agents-md/agent/lib/config.ts

@@ -0,0 +1,8 @@
+export const REPOS: readonly string[] = ["owner/repo"];
+export const SLACK_CHANNELS: readonly string[] = ["#eng"];
+
+const SKIP = new Set(["", "none", "-"]);
+
+export function slackChannels(): readonly string[] {
+  return SLACK_CHANNELS.filter((name) => !SKIP.has(name.toLowerCase()));
+}

package/templates/agents-md/agent/lib/paths.ts

@@ -0,0 +1,51 @@
+export const BRANCH_PREFIX = "agents-md";
+export const TREE_PREFIX = "week/tree";
+
+const PATH = /^[A-Za-z0-9._/-]+$/;
+const REF = /^[A-Za-z0-9._/-]+$/;
+
+export function isAgentsPath(path: string): boolean {
+  return path === "AGENTS.md" || path.endsWith("/AGENTS.md");
+}
+
+export function snapshotPath(path: string): string {
+  return `${TREE_PREFIX}/${path}.txt`;
+}
+
+export function agentsPath(raw: string): string | undefined {
+  let path = raw.replace(/^\/+/, "");
+  if (path.startsWith(`${TREE_PREFIX}/`)) {
+    path = path.slice(TREE_PREFIX.length + 1);
+    if (path.endsWith(".txt")) {
+      path = path.slice(0, -4);
+    }
+  }
+  if (path.includes("..") || path.includes("\\") || !PATH.test(path)) {
+    return undefined;
+  }
+  if (!isAgentsPath(path)) {
+    return undefined;
+  }
+  return path;
+}
+
+export function isUpdateRef(ref: string): boolean {
+  return ref === BRANCH_PREFIX || ref.startsWith(`${BRANCH_PREFIX}/`);
+}
+
+export function updateBranch(base: string): string | undefined {
+  if (base === "" || !REF.test(base)) {
+    return undefined;
+  }
+  return `${BRANCH_PREFIX}/${base.replaceAll("/", "-")}`;
+}
+
+export function parseRepo(
+  raw: string
+): { owner: string; repo: string } | undefined {
+  const match = /^([A-Za-z0-9._-]+)\/([A-Za-z0-9._-]+)$/.exec(raw.trim());
+  if (match === null || match[1] === undefined || match[2] === undefined) {
+    return undefined;
+  }
+  return { owner: match[1], repo: match[2] };
+}

package/templates/agents-md/agent/schedules/weekly.ts

@@ -0,0 +1,17 @@
+import { defineSchedule } from "@cursor/july/schedules";
+import queue from "../channels/queue.js";
+import { collectWeek } from "../lib/collect.js";
+
+export default defineSchedule({
+  cron: "0 9 * * 1",
+  async run({ receive, waitUntil, appAuth, host }) {
+    const week = await collectWeek(host);
+    waitUntil(
+      receive(queue, {
+        message: week.prompt,
+        auth: appAuth,
+        target: week,
+      })
+    );
+  },
+});