@letta-ai/letta-code 0.30.28 → 0.30.30

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,
+  }));
+}

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

@@ -0,0 +1,371 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+export const PI_AI_PACKAGE = "@earendil-works/pi-ai";
+export const PI_AI_REPO = "earendil-works/pi";
+export const DEFAULT_TARGET_REPO =
+  process.env.GITHUB_REPOSITORY || "letta-ai/letta-code";
+
+interface RegistryVersion {
+  version: string;
+  gitHead?: string;
+  dist?: {
+    integrity?: string;
+    tarball?: string;
+  };
+}
+
+interface RegistryMetadata {
+  versions?: Record<string, RegistryVersion>;
+  time?: Record<string, string>;
+}
+
+export interface PackageRelease {
+  version: string;
+  published_at: string;
+  integrity: string | null;
+  tarball_url: string | null;
+  git_head: string | null;
+}
+
+export interface AnalyzePiAiReleaseOptions {
+  previousVersion: string | null;
+  currentVersion: string | null;
+  installedVersion?: string;
+  stableReleases?: PackageRelease[];
+}
+
+export interface PiAiWatchAnalysis {
+  package: typeof PI_AI_PACKAGE;
+  installed_version: string;
+  previous_version: string;
+  current_version: string;
+  is_adjacent_release: boolean;
+  published_at: string;
+  integrity: string | null;
+  tarball_url: string | null;
+  git_head: string | null;
+  release_url: string;
+  compare_url: string;
+  changelog_md: string;
+  changed_files: string[];
+  diff_stat: string;
+  package_json_diff: string | null;
+  workflow_run_url: string;
+}
+
+export async function analyzePiAiRelease(
+  options: AnalyzePiAiReleaseOptions,
+): Promise<PiAiWatchAnalysis> {
+  const releases = options.stableReleases ?? (await listStableReleases());
+  if (releases.length === 0) throw new Error("No stable pi-ai releases found");
+
+  const current = options.currentVersion
+    ? releases.find((release) => release.version === options.currentVersion)
+    : releases.at(-1);
+  if (!current) {
+    throw new Error(
+      `Could not find current pi-ai release ${options.currentVersion}`,
+    );
+  }
+
+  const previous = options.previousVersion
+    ? releases.find((release) => release.version === options.previousVersion)
+    : findPreviousStableRelease(releases, current.version);
+  if (!previous) {
+    throw new Error(
+      `Could not find previous pi-ai release before ${current.version}`,
+    );
+  }
+
+  const installedVersion = options.installedVersion ?? readInstalledVersion();
+  const previousTag = `v${previous.version}`;
+  const currentTag = `v${current.version}`;
+  const temp = mkdtempSync(join(tmpdir(), "pi-ai-watch-"));
+  try {
+    const repoDir = clonePi(temp);
+    fetchTag(repoDir, previousTag);
+    fetchTag(repoDir, currentTag);
+    verifyTagMatchesPackage(repoDir, previousTag, previous);
+    verifyTagMatchesPackage(repoDir, currentTag, current);
+    const changelog = showFile(repoDir, currentTag, "packages/ai/CHANGELOG.md");
+    if (changelog === null) {
+      throw new Error(`packages/ai/CHANGELOG.md is missing at ${currentTag}`);
+    }
+
+    return {
+      package: PI_AI_PACKAGE,
+      installed_version: installedVersion,
+      previous_version: previous.version,
+      current_version: current.version,
+      is_adjacent_release: areAdjacentStableReleases(
+        releases,
+        previous.version,
+        current.version,
+      ),
+      published_at: current.published_at,
+      integrity: current.integrity,
+      tarball_url: current.tarball_url,
+      git_head: current.git_head,
+      release_url: `https://github.com/${PI_AI_REPO}/releases/tag/${currentTag}`,
+      compare_url: `https://github.com/${PI_AI_REPO}/compare/${previousTag}...${currentTag}`,
+      changelog_md: extractChangelogSection(changelog, current.version),
+      changed_files: changedFiles(repoDir, previousTag, currentTag),
+      diff_stat: diffStat(repoDir, previousTag, currentTag),
+      package_json_diff: diffPreview(
+        repoDir,
+        previousTag,
+        currentTag,
+        "packages/ai/package.json",
+      ),
+      workflow_run_url: workflowRunUrl(),
+    };
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+export async function listStableReleases(): Promise<PackageRelease[]> {
+  const response = await fetch(
+    "https://registry.npmjs.org/@earendil-works%2Fpi-ai",
+  );
+  if (!response.ok) {
+    throw new Error(
+      `npm registry request failed (${response.status}): ${await response.text()}`,
+    );
+  }
+  return parseRegistryMetadata((await response.json()) as RegistryMetadata);
+}
+
+export function parseRegistryMetadata(
+  metadata: RegistryMetadata,
+): PackageRelease[] {
+  if (!metadata.versions || !metadata.time) {
+    throw new Error(
+      "pi-ai npm metadata is missing versions or publication times",
+    );
+  }
+
+  return Object.entries(metadata.versions)
+    .filter(([version]) => isStableVersion(version))
+    .map(([version, details]) => {
+      const publishedAt = metadata.time?.[version];
+      if (!publishedAt) {
+        throw new Error(
+          `pi-ai npm metadata is missing publication time for ${version}`,
+        );
+      }
+      return {
+        version,
+        published_at: publishedAt,
+        integrity: details.dist?.integrity ?? null,
+        tarball_url: details.dist?.tarball ?? null,
+        git_head: details.gitHead ?? null,
+      };
+    })
+    .sort((left, right) => compareStableVersions(left.version, right.version));
+}
+
+export function readInstalledVersion(lockfilePath = "bun.lock"): string {
+  const lockfile = readFileSync(lockfilePath, "utf8");
+  const escapedPackage = escapeRegExp(PI_AI_PACKAGE);
+  const match = new RegExp(
+    `"${escapedPackage}": \\["${escapedPackage}@(\\d+\\.\\d+\\.\\d+)"`,
+  ).exec(lockfile);
+  if (!match?.[1]) {
+    throw new Error(
+      `Could not parse resolved ${PI_AI_PACKAGE} version from ${lockfilePath}`,
+    );
+  }
+  return match[1];
+}
+
+export function findNextStableRelease(
+  releases: PackageRelease[],
+  cursorVersion: string,
+): PackageRelease | null {
+  const index = releases.findIndex(
+    (release) => release.version === cursorVersion,
+  );
+  if (index < 0) {
+    throw new Error(`Could not find pi-ai cursor release ${cursorVersion}`);
+  }
+  return releases[index + 1] ?? null;
+}
+
+export function areAdjacentStableReleases(
+  releases: PackageRelease[],
+  previousVersion: string,
+  currentVersion: string,
+): boolean {
+  return (
+    findPreviousStableRelease(releases, currentVersion)?.version ===
+    previousVersion
+  );
+}
+
+export function extractChangelogSection(
+  changelog: string,
+  version: string,
+): string {
+  const heading = new RegExp(`^## \\[${escapeRegExp(version)}\\].*$`, "m");
+  const match = heading.exec(changelog);
+  if (!match)
+    throw new Error(`Could not find pi-ai changelog section ${version}`);
+  const start = match.index;
+  const remaining = changelog.slice(start + match[0].length);
+  const next = /^## \[/m.exec(remaining);
+  const end = next ? start + match[0].length + next.index : changelog.length;
+  return changelog.slice(start, end).trim();
+}
+
+function findPreviousStableRelease(
+  releases: PackageRelease[],
+  currentVersion: string,
+): PackageRelease | null {
+  const index = releases.findIndex(
+    (release) => release.version === currentVersion,
+  );
+  if (index <= 0) return null;
+  return releases[index - 1] ?? null;
+}
+
+export function compareStableVersions(left: string, right: string): number {
+  const leftParts = parseVersion(left);
+  const rightParts = parseVersion(right);
+  for (let index = 0; index < leftParts.length; index += 1) {
+    const difference = leftParts[index]! - rightParts[index]!;
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
+
+function parseVersion(version: string): [number, number, number] {
+  const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+  if (!match) throw new Error(`Invalid stable pi-ai version ${version}`);
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+
+function isStableVersion(version: string): boolean {
+  return /^\d+\.\d+\.\d+$/.test(version);
+}
+
+function clonePi(temp: string): string {
+  const directory = join(temp, "pi");
+  git([
+    "clone",
+    "--filter=blob:none",
+    "--no-checkout",
+    `https://github.com/${PI_AI_REPO}.git`,
+    directory,
+  ]);
+  return directory;
+}
+
+function fetchTag(repoDir: string, tag: string): void {
+  git(
+    [
+      "fetch",
+      "--filter=blob:none",
+      "origin",
+      `refs/tags/${tag}:refs/tags/${tag}`,
+    ],
+    repoDir,
+  );
+}
+
+function verifyTagMatchesPackage(
+  repoDir: string,
+  tag: string,
+  release: PackageRelease,
+): void {
+  if (!release.git_head) return;
+  const tagCommit = git(["rev-list", "-n", "1", tag], repoDir).trim();
+  if (tagCommit !== release.git_head) {
+    throw new Error(
+      `pi-ai npm ${release.version} gitHead ${release.git_head} does not match ${tag} commit ${tagCommit}`,
+    );
+  }
+}
+
+function showFile(repoDir: string, tag: string, path: string): string | null {
+  const result = spawnSync("git", ["show", `${tag}:${path}`], {
+    cwd: repoDir,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  return result.status === 0 ? result.stdout : null;
+}
+
+function changedFiles(
+  repoDir: string,
+  previousTag: string,
+  currentTag: string,
+): string[] {
+  return git(
+    [
+      "diff",
+      "--name-only",
+      `${previousTag}..${currentTag}`,
+      "--",
+      "packages/ai",
+    ],
+    repoDir,
+  )
+    .split("\n")
+    .filter(Boolean);
+}
+
+function diffStat(
+  repoDir: string,
+  previousTag: string,
+  currentTag: string,
+): string {
+  return git(
+    ["diff", "--stat", `${previousTag}..${currentTag}`, "--", "packages/ai"],
+    repoDir,
+  ).trim();
+}
+
+function diffPreview(
+  repoDir: string,
+  previousTag: string,
+  currentTag: string,
+  path: string,
+): string | null {
+  const output = git(
+    ["diff", "--unified=3", `${previousTag}..${currentTag}`, "--", path],
+    repoDir,
+  );
+  return output.trim() ? output.split("\n").slice(0, 160).join("\n") : null;
+}
+
+function git(args: string[], cwd?: string): string {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 50 * 1024 * 1024,
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  if (result.status !== 0) {
+    throw new Error(`git ${args.join(" ")} failed:\n${result.stderr}`);
+  }
+  return result.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";
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}