@letta-ai/letta-code 0.30.27 → 0.30.29

package/scripts/pi-ai-watch/agent-watch.ts

@@ -0,0 +1,253 @@
+#!/usr/bin/env bun
+
+import { appendFileSync, writeFileSync } from "node:fs";
+import {
+  createIssueWithBody,
+  editIssueBody,
+  ensureLabels,
+  findIssueByExactTitle,
+  getIssueBody,
+  getPullRequestStatus,
+} from "./github.ts";
+import {
+  analyzePiAiRelease,
+  compareStableVersions,
+  DEFAULT_TARGET_REPO,
+  findNextStableRelease,
+  listStableReleases,
+  readInstalledVersion,
+} from "./release-analysis.ts";
+import {
+  advanceMergedPr,
+  getPendingPrForCursor,
+  hasCompletedRange,
+  initialTrackerState,
+  parseTrackerState,
+  renderTrackerBody,
+} from "./tracker.ts";
+
+const DEFAULT_TRACKER_TITLE = "pi-ai dependency upgrade tracker";
+const DEFAULT_ANALYSIS_FILE = "pi-ai-watch-analysis.json";
+
+interface Args {
+  dryRun: boolean;
+  previousVersion: string | null;
+  currentVersion: string | null;
+  repo: string;
+  trackerTitle: string;
+  analysisFile: string;
+}
+
+interface TrackerIssue {
+  number: number;
+  url: string;
+  body: string;
+}
+
+function parseArgs(argv: string[]): Args {
+  const args: Args = {
+    dryRun: false,
+    previousVersion: null,
+    currentVersion: null,
+    repo: DEFAULT_TARGET_REPO,
+    trackerTitle: DEFAULT_TRACKER_TITLE,
+    analysisFile: DEFAULT_ANALYSIS_FILE,
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "--dry-run") args.dryRun = true;
+    else if (argument === "--previous-version") {
+      args.previousVersion = argv[++index] ?? null;
+    } else if (argument === "--current-version") {
+      args.currentVersion = argv[++index] ?? null;
+    } else if (argument === "--repo") {
+      args.repo = argv[++index] ?? args.repo;
+    } else if (argument === "--tracker-title") {
+      args.trackerTitle = argv[++index] ?? args.trackerTitle;
+    } else if (argument === "--analysis-file") {
+      args.analysisFile = argv[++index] ?? args.analysisFile;
+    } else if (argument === "--help" || argument === "-h") {
+      console.log(
+        "Usage: bun scripts/pi-ai-watch/agent-watch.ts [--dry-run] [--previous-version VERSION] [--current-version VERSION] [--repo OWNER/REPO] [--tracker-title TITLE] [--analysis-file FILE]",
+      );
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${argument}`);
+    }
+  }
+  return args;
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+  const installedVersion = readInstalledVersion();
+  const tracker = ensureTrackerIssue(args, installedVersion);
+  let state = parseTrackerState(tracker.body);
+  const releases = await listStableReleases();
+  let previousVersion = args.previousVersion;
+  let currentVersion = args.currentVersion;
+  const isScheduledSelection = !previousVersion && !currentVersion;
+
+  if (isScheduledSelection) {
+    const pending = getPendingPrForCursor(state);
+    if (pending?.pr_url) {
+      const status = getPullRequestStatus(pending.pr_url);
+      if (status.state === "OPEN") {
+        console.log(`Waiting for pending pi-ai upgrade PR: ${status.url}`);
+        writeCommonOutputs(tracker, {
+          installedVersion,
+          previousVersion: pending.previous_version,
+          currentVersion: pending.version,
+        });
+        writeOutput("pending_pr_url", status.url);
+        writeOutput("should_run_agent", "false");
+        return;
+      }
+      if (status.state === "MERGED") {
+        if (compareStableVersions(installedVersion, pending.version) < 0) {
+          throw new Error(
+            `Merged pi-ai PR ${status.url} targets ${pending.version}, but main still declares ${installedVersion}`,
+          );
+        }
+        state = advanceMergedPr(state, pending.version);
+        if (!args.dryRun) {
+          editIssueBody(args.repo, tracker.number, renderTrackerBody(state));
+        }
+      } else {
+        console.log(
+          `Retrying ${pending.version}; prior PR was closed unmerged.`,
+        );
+      }
+    }
+
+    const next = findNextStableRelease(releases, state.audit_cursor_version);
+    if (!next) {
+      console.log(
+        `No stable pi-ai release after ${state.audit_cursor_version}.`,
+      );
+      writeCommonOutputs(tracker, {
+        installedVersion,
+        previousVersion: state.audit_cursor_version,
+        currentVersion: state.audit_cursor_version,
+      });
+      writeOutput("should_run_agent", "false");
+      return;
+    }
+    previousVersion = state.audit_cursor_version;
+    currentVersion = next.version;
+  }
+
+  const analysis = await analyzePiAiRelease({
+    previousVersion,
+    currentVersion,
+    installedVersion,
+    stableReleases: releases,
+  });
+  writeFileSync(args.analysisFile, `${JSON.stringify(analysis, null, 2)}\n`);
+  writeCommonOutputs(tracker, {
+    installedVersion,
+    previousVersion: analysis.previous_version,
+    currentVersion: analysis.current_version,
+  });
+  writeOutput("analysis_file", args.analysisFile);
+
+  if (
+    !args.dryRun &&
+    hasCompletedRange(
+      state,
+      analysis.previous_version,
+      analysis.current_version,
+    )
+  ) {
+    console.log(
+      `Already completed pi-ai review ${analysis.previous_version}...${analysis.current_version}.`,
+    );
+    writeOutput("should_run_agent", "false");
+    return;
+  }
+
+  if (args.dryRun) {
+    console.log(JSON.stringify(analysis, null, 2));
+    writeOutput("should_run_agent", "false");
+    return;
+  }
+
+  console.log(
+    `pi-ai ${analysis.previous_version}...${analysis.current_version} needs Amelia review.`,
+  );
+  writeOutput("should_run_agent", "true");
+}
+
+function ensureTrackerIssue(
+  args: Args,
+  installedVersion: string,
+): TrackerIssue {
+  const existing = args.dryRun
+    ? null
+    : findIssueByExactTitle(args.repo, args.trackerTitle);
+  if (existing) {
+    return {
+      number: existing.number,
+      url: `https://github.com/${args.repo}/issues/${existing.number}`,
+      body: getIssueBody(args.repo, existing.number),
+    };
+  }
+
+  const body = renderTrackerBody(initialTrackerState(installedVersion));
+  if (args.dryRun) {
+    return {
+      number: 0,
+      url: `https://github.com/${args.repo}/issues/0`,
+      body,
+    };
+  }
+
+  const labels = ["pi-ai-watch", "automation"];
+  ensureLabels(args.repo, labels);
+  const issueUrl = createIssueWithBody(
+    args.repo,
+    args.trackerTitle,
+    body,
+    labels,
+  );
+  return {
+    number: issueNumberFromUrl(issueUrl),
+    url: issueUrl,
+    body,
+  };
+}
+
+function issueNumberFromUrl(issueUrl: string): number {
+  const issueNumber = Number(issueUrl.trim().split("/").at(-1));
+  if (!Number.isInteger(issueNumber) || issueNumber <= 0) {
+    throw new Error(`Could not parse issue number from ${issueUrl}`);
+  }
+  return issueNumber;
+}
+
+function writeCommonOutputs(
+  tracker: TrackerIssue,
+  versions: {
+    installedVersion: string;
+    previousVersion: string;
+    currentVersion: string;
+  },
+): void {
+  writeOutput("tracker_issue", String(tracker.number));
+  writeOutput("tracker_issue_url", tracker.url);
+  writeOutput("installed_version", versions.installedVersion);
+  writeOutput("previous_version", versions.previousVersion);
+  writeOutput("current_version", versions.currentVersion);
+}
+
+function writeOutput(name: string, value: string): void {
+  const outputPath = process.env.GITHUB_OUTPUT;
+  if (!outputPath) return;
+  appendFileSync(outputPath, `${name}=${value}\n`);
+}
+
+main().catch((error) => {
+  console.error(error);
+  writeOutput("should_run_agent", "false");
+  process.exit(1);
+});

package/scripts/pi-ai-watch/github.ts

@@ -0,0 +1,145 @@
+import { spawnSync } from "node:child_process";
+import { rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export interface PullRequestStatus {
+  state: "OPEN" | "CLOSED" | "MERGED";
+  url: string;
+}
+
+export function runGh(args: string[], input?: string): string {
+  const result = spawnSync("gh", args, {
+    encoding: "utf8",
+    input,
+    maxBuffer: 50 * 1024 * 1024,
+    stdio: input ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
+  });
+  if (result.status !== 0) {
+    throw new Error(`gh ${args.join(" ")} failed:\n${result.stderr}`);
+  }
+  return result.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 result = spawnSync("gh", ["label", "create", label, "--repo", repo], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.status !== 0 && !result.stderr.includes("already exists")) {
+      throw new Error(`gh label create ${label} failed:\n${result.stderr}`);
+    }
+  }
+}
+
+export function createIssueWithBody(
+  repo: string,
+  title: string,
+  body: string,
+  labels: string[],
+): string {
+  const bodyFile = writeTempMarkdown(body, "pi-ai-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, "pi-ai-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 } | null {
+  const issues = ghJson<Array<{ number: number; title: string }>>([
+    "issue",
+    "list",
+    "--repo",
+    repo,
+    "--state",
+    "all",
+    "--search",
+    `${title} in:title`,
+    "--limit",
+    "20",
+    "--json",
+    "number,title",
+  ]);
+  return issues.find((issue) => issue.title === title) ?? null;
+}
+
+export function getPullRequestStatus(prUrl: string): PullRequestStatus {
+  const match = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)$/.exec(
+    prUrl,
+  );
+  if (!match) throw new Error(`Invalid GitHub pull request URL ${prUrl}`);
+  const [, owner, repo, number] = match;
+  const pull = ghJson<{ state: "OPEN" | "CLOSED"; mergedAt: string | null }>([
+    "pr",
+    "view",
+    number as string,
+    "--repo",
+    `${owner}/${repo}`,
+    "--json",
+    "state,mergedAt",
+  ]);
+  return {
+    state: pull.mergedAt ? "MERGED" : pull.state,
+    url: prUrl,
+  };
+}
+
+function writeTempMarkdown(body: string, prefix: string): string {
+  const path = join(tmpdir(), `${prefix}-${Date.now()}.md`);
+  writeFileSync(path, body);
+  return path;
+}

package/scripts/pi-ai-watch/release-analysis.test.ts

@@ -0,0 +1,137 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  areAdjacentStableReleases,
+  compareStableVersions,
+  extractChangelogSection,
+  findNextStableRelease,
+  type PackageRelease,
+  parseRegistryMetadata,
+  readInstalledVersion,
+} from "./release-analysis.ts";
+
+const temporaryDirectories: string[] = [];
+
+afterEach(() => {
+  for (const directory of temporaryDirectories.splice(0)) {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});
+
+describe("pi-ai npm releases", () => {
+  test("filters prereleases and orders stable versions semantically", () => {
+    const releases = parseRegistryMetadata({
+      versions: {
+        "0.10.0": {
+          version: "0.10.0",
+          gitHead: "new",
+          dist: { integrity: "sha-new", tarball: "https://example/new.tgz" },
+        },
+        "0.9.1-beta.0": { version: "0.9.1-beta.0" },
+        "0.9.2": { version: "0.9.2" },
+      },
+      time: {
+        "0.10.0": "2026-01-03T00:00:00Z",
+        "0.9.1-beta.0": "2026-01-01T00:00:00Z",
+        "0.9.2": "2026-01-02T00:00:00Z",
+      },
+    });
+
+    expect(releases.map((release) => release.version)).toEqual([
+      "0.9.2",
+      "0.10.0",
+    ]);
+    expect(releases[1]).toMatchObject({
+      integrity: "sha-new",
+      tarball_url: "https://example/new.tgz",
+      git_head: "new",
+    });
+  });
+
+  test("rejects stable releases without publication times", () => {
+    expect(() =>
+      parseRegistryMetadata({
+        versions: { "0.82.1": { version: "0.82.1" } },
+        time: {},
+      }),
+    ).toThrow("missing publication time for 0.82.1");
+  });
+
+  test("selects exactly the next stable version after the cursor", () => {
+    const releases = releaseList("0.82.1", "0.83.0", "0.84.0");
+    expect(findNextStableRelease(releases, "0.82.1")?.version).toBe("0.83.0");
+    expect(findNextStableRelease(releases, "0.84.0")).toBeNull();
+    expect(() => findNextStableRelease(releases, "0.80.0")).toThrow(
+      "Could not find pi-ai cursor release 0.80.0",
+    );
+  });
+
+  test("recognizes only adjacent release pairs", () => {
+    const releases = releaseList("0.82.1", "0.83.0", "0.84.0");
+    expect(areAdjacentStableReleases(releases, "0.82.1", "0.83.0")).toBe(true);
+    expect(areAdjacentStableReleases(releases, "0.82.1", "0.84.0")).toBe(false);
+  });
+});
+
+describe("pi-ai release evidence", () => {
+  test("extracts only the requested changelog section", () => {
+    const changelog = `# Changelog
+
+## [0.84.0] - 2026-08-06
+
+### Added
+
+- Current feature.
+
+## [0.83.0] - 2026-07-29
+
+- Previous feature.
+`;
+    expect(
+      extractChangelogSection(changelog, "0.84.0"),
+    ).toBe(`## [0.84.0] - 2026-08-06
+
+### Added
+
+- Current feature.`);
+    expect(() => extractChangelogSection(changelog, "0.82.1")).toThrow(
+      "Could not find pi-ai changelog section 0.82.1",
+    );
+  });
+
+  test("reads the exact resolved version from bun.lock", () => {
+    const directory = mkdtempSync(join(tmpdir(), "pi-ai-watch-test-"));
+    temporaryDirectories.push(directory);
+    const lockfile = join(directory, "bun.lock");
+    writeFileSync(
+      lockfile,
+      `{
+  "workspaces": {
+    "": { "dependencies": { "@earendil-works/pi-ai": "^0.82.0" } }
+  },
+  "packages": {
+    "@earendil-works/pi-ai": ["@earendil-works/pi-ai@0.82.1", ""]
+  }
+}`,
+    );
+    expect(readInstalledVersion(lockfile)).toBe("0.82.1");
+  });
+
+  test("compares multi-digit semantic version components", () => {
+    expect(compareStableVersions("0.9.9", "0.10.0")).toBeLessThan(0);
+    expect(compareStableVersions("1.0.0", "0.99.99")).toBeGreaterThan(0);
+    expect(compareStableVersions("0.84.2", "0.84.2")).toBe(0);
+  });
+});
+
+function releaseList(...versions: string[]): PackageRelease[] {
+  return versions.map((version, index) => ({
+    version,
+    published_at: `2026-08-${String(index + 1).padStart(2, "0")}T00:00:00Z`,
+    integrity: null,
+    tarball_url: null,
+    git_head: null,
+  }));
+}