@letta-ai/letta-code 0.27.20 → 0.27.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.27.20",
+  "version": "0.27.22",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "packageManager": "bun@1.3.0",
@@ -16,6 +16,8 @@
     "vendor",
     "dist/app-server-client.js",
     "dist/app-server-client.js.map",
+    "dist/agent-presets.js",
+    "dist/agent-presets.js.map",
     "dist/types",
     "docs"
   ],
@@ -30,6 +32,10 @@
     },
     "./protocol": {
       "types": "./dist/types/protocol.d.ts"
+    },
+    "./agent-presets": {
+      "types": "./dist/types/agent-presets.d.ts",
+      "import": "./dist/agent-presets.js"
     }
   },
   "repository": {
@@ -105,5 +111,21 @@
     "*.{ts,tsx,js,jsx,json}": [
       "bunx --bun @biomejs/biome@2.2.5 check --write"
     ]
+  },
+  "typesVersions": {
+    "*": {
+      "agent-presets": [
+        "./dist/types/agent-presets.d.ts"
+      ],
+      "app-server-protocol": [
+        "./dist/types/app-server-protocol.d.ts"
+      ],
+      "app-server-client": [
+        "./dist/types/app-server-client.d.ts"
+      ],
+      "protocol": [
+        "./dist/types/protocol.d.ts"
+      ]
+    }
   }
 }

package/scripts/codex-watch/agent-watch.ts

@@ -0,0 +1,186 @@
+#!/usr/bin/env bun
+/**
+ * Amelia-driven Codex release watcher entrypoint.
+ *
+ * This runs alongside the legacy per-release issue workflow. It uses a central
+ * tracker issue for state and only asks Amelia to review non-noop releases.
+ */
+
+import { appendFileSync, writeFileSync } from "node:fs";
+import {
+  createIssueWithBody,
+  editIssueBody,
+  ensureLabels,
+  findIssueByExactTitle,
+  getIssueBody,
+} from "./github.ts";
+import {
+  analyzeCodexRelease,
+  DEFAULT_TARGET_REPO,
+} from "./release-analysis.ts";
+import {
+  emptyTrackerState,
+  hasProcessedTag,
+  parseTrackerState,
+  recordAnalysis,
+  renderTrackerBody,
+} from "./tracker.ts";
+
+const DEFAULT_TRACKER_TITLE = "Codex upstream drift tracker";
+const DEFAULT_ANALYSIS_FILE = "codex-watch-analysis.json";
+
+interface Args {
+  dryRun: boolean;
+  sinceTag: string | null;
+  currentTag: 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,
+    sinceTag: null,
+    currentTag: null,
+    repo: DEFAULT_TARGET_REPO,
+    trackerTitle: DEFAULT_TRACKER_TITLE,
+    analysisFile: DEFAULT_ANALYSIS_FILE,
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--dry-run") args.dryRun = true;
+    else if (a === "--since") args.sinceTag = argv[++i] ?? null;
+    else if (a === "--current") args.currentTag = argv[++i] ?? null;
+    else if (a === "--repo") args.repo = argv[++i] ?? args.repo;
+    else if (a === "--tracker-title") {
+      args.trackerTitle = argv[++i] ?? args.trackerTitle;
+    } else if (a === "--analysis-file") {
+      args.analysisFile = argv[++i] ?? args.analysisFile;
+    } else if (a === "--help" || a === "-h") {
+      console.log(
+        "Usage: bun scripts/codex-watch/agent-watch.ts [--dry-run] [--since TAG] [--current TAG] [--repo OWNER/REPO] [--tracker-title TITLE] [--analysis-file FILE]",
+      );
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown argument: ${a}`);
+    }
+  }
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const analysis = await analyzeCodexRelease({
+    sinceTag: args.sinceTag,
+    currentTag: args.currentTag,
+  });
+  writeFileSync(args.analysisFile, `${JSON.stringify(analysis, null, 2)}\n`);
+
+  const tracker = ensureTrackerIssue(args);
+  const state = parseTrackerState(tracker.body);
+
+  writeOutput("tracker_issue", String(tracker.number));
+  writeOutput("tracker_issue_url", tracker.url);
+  writeOutput("analysis_file", args.analysisFile);
+  writeOutput("current_tag", analysis.current_tag);
+  writeOutput("previous_tag", analysis.previous_tag);
+  writeOutput("verdict", analysis.verdict);
+
+  if (!args.dryRun && hasProcessedTag(state, analysis.current_tag)) {
+    console.log(`Already processed ${analysis.current_tag}; nothing to do.`);
+    writeOutput("should_run_agent", "false");
+    return;
+  }
+
+  if (analysis.verdict === "no-op") {
+    const next = recordAnalysis(state, {
+      analysis,
+      outcome: "recorded_noop",
+      notes: "no watched tool-surface changes detected",
+    });
+    const nextBody = renderTrackerBody(next);
+    if (args.dryRun) {
+      console.log(nextBody);
+    } else {
+      editIssueBody(args.repo, tracker.number, nextBody);
+    }
+    console.log(`Recorded ${analysis.current_tag} as no-op.`);
+    writeOutput("should_run_agent", "false");
+    return;
+  }
+
+  if (args.dryRun) {
+    console.log(JSON.stringify(analysis, null, 2));
+    writeOutput("should_run_agent", "false");
+    return;
+  }
+
+  console.log(
+    `Release ${analysis.current_tag} needs Amelia review: ${analysis.verdict}`,
+  );
+  writeOutput("should_run_agent", "true");
+}
+
+function ensureTrackerIssue(args: Args): 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(emptyTrackerState());
+  if (args.dryRun) {
+    return {
+      number: 0,
+      url: `https://github.com/${args.repo}/issues/0`,
+      body,
+    };
+  }
+
+  const labels = ["codex-watch", "automation"];
+  ensureLabels(args.repo, labels);
+  const issueUrl = createIssueWithBody(
+    args.repo,
+    args.trackerTitle,
+    body,
+    labels,
+  );
+  const issueNumber = issueNumberFromUrl(issueUrl);
+  return {
+    number: issueNumber,
+    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 writeOutput(name: string, value: string): void {
+  const outputPath = process.env.GITHUB_OUTPUT;
+  if (!outputPath) return;
+  appendFileSync(outputPath, `${name}=${value}\n`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  writeOutput("should_run_agent", "false");
+  process.exit(1);
+});

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

@@ -9,41 +9,13 @@
  *   bun scripts/codex-watch/check-release.ts --repo letta-ai/letta-code
  */
 
-import { spawnSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { createIssueWithBody, ensureLabels, ghJson } from "./github.ts";
 import {
-  decideVerdict,
-  diffModelsJson,
-  type ModelsDiff,
-  type ModelsJson,
-} from "./diff-models-json.ts";
-import {
-  type PathChangeSummary,
-  renderBody,
-  renderTitle,
-} from "./render-issue.ts";
-
-const CODEX_REPO = "openai/codex";
-const DEFAULT_TARGET_REPO =
-  process.env.GITHUB_REPOSITORY || "letta-ai/letta-code";
-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;
-
-interface Release {
-  tag_name: string;
-  draft: boolean;
-  prerelease: boolean;
-  html_url: string;
-  body: string | null;
-  published_at: string | null;
-}
+  analyzeCodexRelease,
+  DEFAULT_TARGET_REPO,
+  listStableReleases,
+} from "./release-analysis.ts";
+import { renderBody, renderTitle } from "./render-issue.ts";
 
 interface Args {
   dryRun: boolean;
@@ -77,73 +49,8 @@ function parseArgs(argv: string[]): Args {
   return args;
 }
 
-function gh<T>(args: string[], input?: string): T {
-  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 JSON.parse(res.stdout) as T;
-}
-
-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 isStableRelease(release: Release): boolean {
-  if (release.draft || release.prerelease) return false;
-  return /^(rust-v|v)?\d+\.\d+\.\d+$/.test(release.tag_name);
-}
-
-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 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 hasReportedTag(targetRepo: string, tag: string): boolean {
-  const issues = gh<Array<{ title: string }>>([
+  const issues = ghJson<Array<{ title: string }>>([
     "issue",
     "list",
     "--repo",
@@ -162,70 +69,6 @@ function hasReportedTag(targetRepo: string, tag: string): boolean {
   );
 }
 
-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 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 createIssue(
   repo: string,
   title: string,
@@ -242,41 +85,7 @@ function createIssue(
   if (verdict === "no-op") labels.push("informational");
 
   ensureLabels(repo, labels);
-
-  const bodyFile = join(tmpdir(), `codex-watch-${Date.now()}.md`);
-  writeFileSync(bodyFile, body);
-  try {
-    const args = [
-      "issue",
-      "create",
-      "--repo",
-      repo,
-      "--title",
-      title,
-      "--body-file",
-      bodyFile,
-    ];
-    for (const label of labels) args.push("--label", label);
-    const res = spawnSync("gh", args, { encoding: "utf8" });
-    if (res.status !== 0) {
-      throw new Error(`gh ${args.join(" ")} failed:\n${res.stderr}`);
-    }
-    console.log(res.stdout.trim());
-  } finally {
-    rmSync(bodyFile, { force: true });
-  }
-}
-
-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}`);
-    }
-  }
+  console.log(createIssueWithBody(repo, title, body, labels));
 }
 
 async function main() {
@@ -290,15 +99,6 @@ async function main() {
   if (!current)
     throw new Error(`Could not find current release ${args.currentTag}`);
 
-  const previous = args.sinceTag
-    ? (stables.find((r) => r.tag_name === args.sinceTag) ??
-      ({ tag_name: args.sinceTag } as Release))
-    : findPreviousStable(stables, current.tag_name);
-  if (!previous)
-    throw new Error(
-      `Could not find previous stable before ${current.tag_name}`,
-    );
-
   const alreadyReported = args.dryRun
     ? false
     : hasReportedTag(args.repo, current.tag_name);
@@ -307,116 +107,18 @@ async function main() {
     return;
   }
 
-  const tmp = mkdtempSync(join(tmpdir(), "codex-watch-"));
-  try {
-    const repoDir = cloneCodex(tmp);
-    git(
-      [
-        "fetch",
-        "--filter=blob:none",
-        "origin",
-        `refs/tags/${previous.tag_name}:refs/tags/${previous.tag_name}`,
-      ],
-      repoDir,
-    );
-    git(
-      [
-        "fetch",
-        "--filter=blob:none",
-        "origin",
-        `refs/tags/${current.tag_name}:refs/tags/${current.tag_name}`,
-      ],
-      repoDir,
-    );
-
-    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);
-
-    const workflowUrl =
-      process.env.GITHUB_SERVER_URL &&
-      process.env.GITHUB_REPOSITORY &&
-      process.env.GITHUB_RUN_ID
-        ? `${process.env.GITHUB_SERVER_URL}/${process.env.GITHUB_REPOSITORY}/actions/runs/${process.env.GITHUB_RUN_ID}`
-        : "local dry-run";
-
-    const input = {
-      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: workflowUrl,
-    };
+  const analysis = await analyzeCodexRelease({
+    sinceTag: args.sinceTag,
+    currentTag: args.currentTag,
+  });
 
-    const title = renderTitle(input);
-    const body = renderBody(input);
+  const title = renderTitle(analysis);
+  const body = renderBody(analysis);
 
-    if (args.dryRun) {
-      console.log(`# ${title}\n\n${body}`);
-    } else {
-      createIssue(args.repo, title, body, verdict);
-    }
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
+  if (args.dryRun) {
+    console.log(`# ${title}\n\n${body}`);
+  } else {
+    createIssue(args.repo, title, body, analysis.verdict);
   }
 }