@letta-ai/letta-code 0.27.20 → 0.27.22

package/scripts/codex-watch/github.ts

@@ -0,0 +1,121 @@
+import { spawnSync } from "node:child_process";
+import { rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export function runGh(args: string[], input?: string): string {
+  const res = spawnSync("gh", args, {
+    encoding: "utf8",
+    input,
+    maxBuffer: 50 * 1024 * 1024,
+    stdio: input ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
+  });
+  if (res.status !== 0) {
+    throw new Error(`gh ${args.join(" ")} failed:\n${res.stderr}`);
+  }
+  return res.stdout;
+}
+
+export function ghJson<T>(args: string[], input?: string): T {
+  return JSON.parse(runGh(args, input)) as T;
+}
+
+export function ensureLabels(repo: string, labels: string[]): void {
+  for (const label of labels) {
+    const res = spawnSync("gh", ["label", "create", label, "--repo", repo], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (res.status !== 0 && !res.stderr.includes("already exists")) {
+      throw new Error(`gh label create ${label} failed:\n${res.stderr}`);
+    }
+  }
+}
+
+export function createIssueWithBody(
+  repo: string,
+  title: string,
+  body: string,
+  labels: string[] = [],
+): string {
+  const bodyFile = writeTempMarkdown(body, "codex-watch-issue");
+  try {
+    const args = [
+      "issue",
+      "create",
+      "--repo",
+      repo,
+      "--title",
+      title,
+      "--body-file",
+      bodyFile,
+    ];
+    for (const label of labels) args.push("--label", label);
+    return runGh(args).trim();
+  } finally {
+    rmSync(bodyFile, { force: true });
+  }
+}
+
+export function editIssueBody(
+  repo: string,
+  issueNumber: number,
+  body: string,
+): void {
+  const bodyFile = writeTempMarkdown(body, "codex-watch-tracker");
+  try {
+    runGh([
+      "issue",
+      "edit",
+      String(issueNumber),
+      "--repo",
+      repo,
+      "--body-file",
+      bodyFile,
+    ]);
+  } finally {
+    rmSync(bodyFile, { force: true });
+  }
+}
+
+export function getIssueBody(repo: string, issueNumber: number): string {
+  const issue = ghJson<{ body: string | null }>([
+    "issue",
+    "view",
+    String(issueNumber),
+    "--repo",
+    repo,
+    "--json",
+    "body",
+  ]);
+  return issue.body ?? "";
+}
+
+export function findIssueByExactTitle(
+  repo: string,
+  title: string,
+): { number: number; title: string; state: string } | null {
+  const issues = ghJson<
+    Array<{ number: number; title: string; state: string }>
+  >([
+    "issue",
+    "list",
+    "--repo",
+    repo,
+    "--state",
+    "all",
+    "--search",
+    `${title} in:title`,
+    "--limit",
+    "20",
+    "--json",
+    "number,title,state",
+  ]);
+  return issues.find((issue) => issue.title === title) ?? null;
+}
+
+function writeTempMarkdown(body: string, prefix: string): string {
+  const bodyFile = join(tmpdir(), `${prefix}-${Date.now()}.md`);
+  writeFileSync(bodyFile, body);
+  return bodyFile;
+}

package/scripts/codex-watch/release-analysis.ts

@@ -0,0 +1,288 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  decideVerdict,
+  diffModelsJson,
+  type ModelsDiff,
+  type ModelsJson,
+  type Verdict,
+} from "./diff-models-json.ts";
+import type { PathChangeSummary, RenderInput } from "./render-issue.ts";
+
+export const CODEX_REPO = "openai/codex";
+export const DEFAULT_TARGET_REPO =
+  process.env.GITHUB_REPOSITORY || "letta-ai/letta-code";
+export const WATCHED_PATHS = [
+  "codex-rs/models-manager/models.json",
+  "codex-rs/models-manager/prompt.md",
+  "codex-rs/core/src/tools",
+  "codex-rs/apply-patch",
+];
+
+const MAX_COMMITS_PER_PATH = 8;
+
+export interface Release {
+  tag_name: string;
+  draft: boolean;
+  prerelease: boolean;
+  html_url: string;
+  body: string | null;
+  published_at: string | null;
+}
+
+export interface AnalyzeCodexReleaseOptions {
+  sinceTag: string | null;
+  currentTag: string | null;
+}
+
+export interface CodexWatchAnalysis extends RenderInput {
+  verdict: Verdict;
+  models_diff: ModelsDiff | null;
+  compare_url: string;
+  changed_files: string[];
+}
+
+export async function analyzeCodexRelease(
+  options: AnalyzeCodexReleaseOptions,
+): Promise<CodexWatchAnalysis> {
+  const stables = await listStableReleases();
+  if (stables.length === 0) throw new Error("No stable Codex releases found");
+
+  const current = options.currentTag
+    ? stables.find((r) => r.tag_name === options.currentTag)
+    : stables.at(-1);
+  if (!current)
+    throw new Error(`Could not find current release ${options.currentTag}`);
+
+  const previous = options.sinceTag
+    ? (stables.find((r) => r.tag_name === options.sinceTag) ??
+      ({ tag_name: options.sinceTag } as Release))
+    : findPreviousStable(stables, current.tag_name);
+  if (!previous)
+    throw new Error(
+      `Could not find previous stable before ${current.tag_name}`,
+    );
+
+  const tmp = mkdtempSync(join(tmpdir(), "codex-watch-"));
+  try {
+    const repoDir = cloneCodex(tmp);
+    fetchTag(repoDir, previous.tag_name);
+    fetchTag(repoDir, current.tag_name);
+
+    let modelsDiff: ModelsDiff | null = null;
+    let parseError = false;
+    try {
+      const prevRaw = showFile(
+        repoDir,
+        previous.tag_name,
+        "codex-rs/models-manager/models.json",
+      );
+      const currRaw = showFile(
+        repoDir,
+        current.tag_name,
+        "codex-rs/models-manager/models.json",
+      );
+      if (!prevRaw || !currRaw)
+        throw new Error("missing models.json at one tag");
+      modelsDiff = diffModelsJson(
+        JSON.parse(prevRaw) as ModelsJson,
+        JSON.parse(currRaw) as ModelsJson,
+      );
+    } catch (err) {
+      parseError = true;
+      console.error(`Failed to parse/diff models.json: ${String(err)}`);
+    }
+
+    const changed = changedFiles(repoDir, previous.tag_name, current.tag_name);
+    const changedSet = new Set(changed);
+    const promptMdChanged = changedSet.has("codex-rs/models-manager/prompt.md");
+    const toolsDirChanged = changed.some((f) =>
+      f.startsWith("codex-rs/core/src/tools/"),
+    );
+    const applyPatchDirChanged = changed.some((f) =>
+      f.startsWith("codex-rs/apply-patch/"),
+    );
+    const verdict = decideVerdict({
+      models_diff: modelsDiff,
+      prompt_md_changed: promptMdChanged,
+      tools_dir_changed: toolsDirChanged,
+      apply_patch_dir_changed: applyPatchDirChanged,
+      parse_error: parseError,
+    });
+
+    const pathChanges: PathChangeSummary[] = WATCHED_PATHS.map((path) => ({
+      path,
+      commits: commitsForPath(
+        repoDir,
+        previous.tag_name,
+        current.tag_name,
+        path,
+      ),
+    })).filter((p) => p.commits.length > 0);
+
+    return {
+      previous_tag: previous.tag_name,
+      current_tag: current.tag_name,
+      release_url: current.html_url,
+      release_notes_md: current.body ?? "",
+      verdict,
+      models_diff: modelsDiff,
+      prompt_md_changed: promptMdChanged,
+      prompt_md_diff_preview: promptMdChanged
+        ? diffPreview(
+            repoDir,
+            previous.tag_name,
+            current.tag_name,
+            "codex-rs/models-manager/prompt.md",
+          )
+        : null,
+      path_changes: pathChanges,
+      workflow_run_url: workflowRunUrl(),
+      compare_url: `https://github.com/${CODEX_REPO}/compare/${previous.tag_name}...${current.tag_name}`,
+      changed_files: changed,
+    };
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+export async function listStableReleases(): Promise<Release[]> {
+  const releases: Release[] = [];
+  const headers: Record<string, string> = {
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+  };
+  const token = process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+  if (token) headers.Authorization = `Bearer ${token}`;
+
+  for (let page = 1; page <= 10; page++) {
+    const url = `https://api.github.com/repos/${CODEX_REPO}/releases?per_page=100&page=${page}`;
+    const res = await fetch(url, { headers });
+    if (!res.ok) {
+      throw new Error(
+        `GitHub releases API failed (${res.status}): ${await res.text()}`,
+      );
+    }
+    const batch = (await res.json()) as Release[];
+    releases.push(...batch);
+    if (batch.length < 100) break;
+  }
+  return releases
+    .filter(isStableRelease)
+    .sort((a, b) => (a.published_at ?? "").localeCompare(b.published_at ?? ""));
+}
+
+function isStableRelease(release: Release): boolean {
+  if (release.draft || release.prerelease) return false;
+  return /^(rust-v|v)?\d+\.\d+\.\d+$/.test(release.tag_name);
+}
+
+function findPreviousStable(
+  stables: Release[],
+  currentTag: string,
+): Release | null {
+  const idx = stables.findIndex((r) => r.tag_name === currentTag);
+  if (idx <= 0) return null;
+  return stables[idx - 1] ?? null;
+}
+
+function cloneCodex(tmp: string): string {
+  const dir = join(tmp, "codex");
+  git([
+    "clone",
+    "--filter=blob:none",
+    "--no-checkout",
+    `https://github.com/${CODEX_REPO}.git`,
+    dir,
+  ]);
+  return dir;
+}
+
+function fetchTag(repoDir: string, tag: string): void {
+  git(
+    [
+      "fetch",
+      "--filter=blob:none",
+      "origin",
+      `refs/tags/${tag}:refs/tags/${tag}`,
+    ],
+    repoDir,
+  );
+}
+
+function showFile(repoDir: string, tag: string, path: string): string | null {
+  const res = spawnSync("git", ["show", `${tag}:${path}`], {
+    cwd: repoDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (res.status !== 0) return null;
+  return res.stdout;
+}
+
+function changedFiles(
+  repoDir: string,
+  prevTag: string,
+  currTag: string,
+): string[] {
+  return git(["diff", "--name-only", `${prevTag}..${currTag}`], repoDir)
+    .split("\n")
+    .filter(Boolean);
+}
+
+function commitsForPath(
+  repoDir: string,
+  prevTag: string,
+  currTag: string,
+  path: string,
+): string[] {
+  const out = git(
+    ["log", "--format=%h %s", `${prevTag}..${currTag}`, "--", path],
+    repoDir,
+  );
+  const commits = out.split("\n").filter(Boolean);
+  if (commits.length <= MAX_COMMITS_PER_PATH) return commits;
+  return [
+    ...commits.slice(0, MAX_COMMITS_PER_PATH),
+    `…and ${commits.length - MAX_COMMITS_PER_PATH} more commits`,
+  ];
+}
+
+function diffPreview(
+  repoDir: string,
+  prevTag: string,
+  currTag: string,
+  path: string,
+): string | null {
+  const out = git(
+    ["diff", "--unified=2", `${prevTag}..${currTag}`, "--", path],
+    repoDir,
+  );
+  if (!out.trim()) return null;
+  return out.split("\n").slice(0, 120).join("\n");
+}
+
+function git(args: string[], cwd?: string): string {
+  const res = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (res.status !== 0) {
+    throw new Error(`git ${args.join(" ")} failed:\n${res.stderr}`);
+  }
+  return res.stdout;
+}
+
+function workflowRunUrl(): string {
+  if (
+    process.env.GITHUB_SERVER_URL &&
+    process.env.GITHUB_REPOSITORY &&
+    process.env.GITHUB_RUN_ID
+  ) {
+    return `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`;
+  }
+  return "local dry-run";
+}

package/scripts/codex-watch/tracker.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from "bun:test";
+import type { CodexWatchAnalysis } from "./release-analysis.ts";
+import {
+  emptyTrackerState,
+  hasProcessedTag,
+  parseTrackerState,
+  recordAnalysis,
+  renderTrackerBody,
+  serializeTrackerState,
+  type TrackerEntry,
+  upsertTrackerEntry,
+} from "./tracker.ts";
+
+function analysis(
+  tag: string,
+  verdict: CodexWatchAnalysis["verdict"] = "no-op",
+): CodexWatchAnalysis {
+  return {
+    previous_tag: "rust-v0.1.0",
+    current_tag: tag,
+    release_url: `https://github.com/openai/codex/releases/tag/${tag}`,
+    release_notes_md: "",
+    verdict,
+    models_diff: null,
+    prompt_md_changed: false,
+    prompt_md_diff_preview: null,
+    path_changes: [],
+    workflow_run_url: "https://github.com/letta-ai/letta-code/actions/runs/1",
+    compare_url: `https://github.com/openai/codex/compare/rust-v0.1.0...${tag}`,
+    changed_files: [],
+  };
+}
+
+function entry(index: number, outcome: TrackerEntry["outcome"]): TrackerEntry {
+  const verdict =
+    outcome === "recorded_noop" ? "no-op" : "tool-surface review needed";
+  return {
+    tag: `rust-v0.${index}.0`,
+    previous_tag: `rust-v0.${index - 1}.0`,
+    verdict,
+    outcome,
+    pr_url:
+      outcome === "pr_created"
+        ? `https://github.com/letta-ai/letta-code/pull/${index}`
+        : null,
+    notes: `notes ${index}`,
+    processed_at: `2026-07-02T00:${String(index).padStart(2, "0")}:00.000Z`,
+    compare_url: `https://github.com/openai/codex/compare/rust-v0.${index - 1}.0...rust-v0.${index}.0`,
+    workflow_run_url: "https://github.com/letta-ai/letta-code/actions/runs/1",
+  };
+}
+
+describe("tracker state", () => {
+  test("returns empty state when hidden state is absent or malformed", () => {
+    expect(parseTrackerState("plain body")).toEqual(emptyTrackerState());
+    expect(
+      parseTrackerState("<!-- codex-agent-watch-state\nnot json\n-->"),
+    ).toEqual(emptyTrackerState());
+  });
+
+  test("round-trips hidden state through rendered body", () => {
+    const state = recordAnalysis(emptyTrackerState(), {
+      analysis: analysis("rust-v0.2.0", "tool-surface review needed"),
+      outcome: "no_local_impact",
+      notes: "upstream-only router change",
+      processedAt: "2026-07-02T00:00:00.000Z",
+    });
+
+    const body = renderTrackerBody(state);
+    expect(parseTrackerState(body)).toEqual(state);
+    expect(body).toContain("rust-v0.2.0");
+    expect(body).toContain("upstream-only router change");
+  });
+
+  test("records noops in hidden state without adding visible table rows", () => {
+    const state = recordAnalysis(emptyTrackerState(), {
+      analysis: analysis("rust-v0.2.0"),
+      outcome: "recorded_noop",
+      notes: "no watched tool-surface changes detected",
+      processedAt: "2026-07-02T00:00:00.000Z",
+    });
+
+    const body = renderTrackerBody(state);
+    expect(hasProcessedTag(parseTrackerState(body), "rust-v0.2.0")).toBe(true);
+    expect(body).toContain("_No actionable releases recorded yet._");
+    expect(body).toContain("no watched changes");
+  });
+
+  test("keeps the last 50 processed releases in hidden state", () => {
+    let state = emptyTrackerState();
+    for (let i = 1; i <= 60; i++) {
+      state = upsertTrackerEntry(state, entry(i, "recorded_noop"));
+    }
+
+    expect(state.processed).toHaveLength(50);
+    expect(state.processed[0]?.tag).toBe("rust-v0.60.0");
+    expect(state.processed.at(-1)?.tag).toBe("rust-v0.11.0");
+    expect(parseTrackerState(serializeTrackerState(state))).toEqual(state);
+  });
+
+  test("renders at most 20 non-noop rows", () => {
+    let state = emptyTrackerState();
+    for (let i = 1; i <= 25; i++) {
+      state = upsertTrackerEntry(state, entry(i, "no_local_impact"));
+    }
+
+    const body = renderTrackerBody(state);
+    expect(body).toContain("| [rust-v0.25.0]");
+    expect(body).toContain("| [rust-v0.6.0]");
+    expect(body).not.toContain("| [rust-v0.5.0]");
+  });
+
+  test("replaces an existing tag instead of duplicating it", () => {
+    let state = upsertTrackerEntry(
+      emptyTrackerState(),
+      entry(2, "recorded_noop"),
+    );
+    state = upsertTrackerEntry(state, {
+      ...entry(2, "pr_created"),
+      notes: "opened a fix",
+    });
+
+    expect(state.processed).toHaveLength(1);
+    expect(state.processed[0]?.outcome).toBe("pr_created");
+    expect(renderTrackerBody(state)).toContain("opened a fix");
+  });
+});