@letta-ai/letta-code 0.25.9 → 0.25.11

package/scripts/codex-watch/diff-models-json.ts

@@ -0,0 +1,207 @@
+/**
+ * Structured diff of openai/codex `codex-rs/models-manager/models.json`.
+ *
+ * We don't care about every field — only the ones that affect the tool/schema
+ * surface exposed to the model. When any of these change, the letta-code
+ * harness (src/agent/prompts/source_codex.md and src/tools/*) may need updating.
+ */
+
+/** Tool-relevant fields lifted off each model entry in models.json. */
+export interface ModelToolConfig {
+  slug: string;
+  apply_patch_tool_type?: string;
+  web_search_tool_type?: string;
+  shell_type?: string;
+  supports_search_tool?: boolean;
+  supports_parallel_tool_calls?: boolean;
+  supports_image_detail_original?: boolean;
+  experimental_supported_tools?: string[];
+  input_modalities?: string[];
+  truncation_policy?: unknown;
+  /** Tool names mentioned anywhere in base_instructions / instructions_template. */
+  prompt_tool_mentions: string[];
+}
+
+/** Substrings we treat as "this prompt mentions tool X". */
+const TOOL_MENTIONS = [
+  "apply_patch",
+  "exec_command",
+  "view_image",
+  "multi_tool_use.parallel",
+  "web_search",
+  "update_plan",
+  "container.exec",
+];
+
+export interface ModelsJson {
+  models: Array<Record<string, unknown>>;
+}
+
+export interface ToolFieldDelta {
+  slug: string;
+  field: string;
+  previous: unknown;
+  current: unknown;
+}
+
+export interface ModelsDiff {
+  added_models: string[];
+  removed_models: string[];
+  field_deltas: ToolFieldDelta[];
+  /** True if any field_delta is in TOOL_SCHEMA_FIELDS. */
+  has_tool_schema_change: boolean;
+  /** True if any prompt_tool_mentions added or removed. */
+  has_prompt_tool_change: boolean;
+}
+
+/** Fields whose change implies a tool-schema update may be needed in letta-code. */
+export const TOOL_SCHEMA_FIELDS = new Set([
+  "apply_patch_tool_type",
+  "web_search_tool_type",
+  "shell_type",
+  "supports_search_tool",
+  "supports_parallel_tool_calls",
+  "experimental_supported_tools",
+  "input_modalities",
+  "truncation_policy",
+]);
+
+function collectMentions(text: string): string[] {
+  const found = new Set<string>();
+  for (const m of TOOL_MENTIONS) {
+    if (text.includes(m)) found.add(m);
+  }
+  return Array.from(found).sort();
+}
+
+export function extractToolConfig(
+  model: Record<string, unknown>,
+): ModelToolConfig {
+  const slug = typeof model.slug === "string" ? model.slug : "<unknown>";
+  const promptText = [
+    typeof model.base_instructions === "string" ? model.base_instructions : "",
+    typeof model.model_messages === "object" && model.model_messages !== null
+      ? JSON.stringify(model.model_messages)
+      : "",
+  ].join("\n");
+  return {
+    slug,
+    apply_patch_tool_type: model.apply_patch_tool_type as string | undefined,
+    web_search_tool_type: model.web_search_tool_type as string | undefined,
+    shell_type: model.shell_type as string | undefined,
+    supports_search_tool: model.supports_search_tool as boolean | undefined,
+    supports_parallel_tool_calls: model.supports_parallel_tool_calls as
+      | boolean
+      | undefined,
+    supports_image_detail_original: model.supports_image_detail_original as
+      | boolean
+      | undefined,
+    experimental_supported_tools: model.experimental_supported_tools as
+      | string[]
+      | undefined,
+    input_modalities: model.input_modalities as string[] | undefined,
+    truncation_policy: model.truncation_policy,
+    prompt_tool_mentions: collectMentions(promptText),
+  };
+}
+
+function equal(a: unknown, b: unknown): boolean {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+/** Compute the diff between two models.json payloads. */
+export function diffModelsJson(prev: ModelsJson, curr: ModelsJson): ModelsDiff {
+  const prevBySlug = new Map<string, ModelToolConfig>();
+  const currBySlug = new Map<string, ModelToolConfig>();
+  for (const m of prev.models) {
+    const cfg = extractToolConfig(m);
+    prevBySlug.set(cfg.slug, cfg);
+  }
+  for (const m of curr.models) {
+    const cfg = extractToolConfig(m);
+    currBySlug.set(cfg.slug, cfg);
+  }
+
+  const added_models: string[] = [];
+  const removed_models: string[] = [];
+  for (const slug of currBySlug.keys()) {
+    if (!prevBySlug.has(slug)) added_models.push(slug);
+  }
+  for (const slug of prevBySlug.keys()) {
+    if (!currBySlug.has(slug)) removed_models.push(slug);
+  }
+
+  const field_deltas: ToolFieldDelta[] = [];
+  let has_tool_schema_change = false;
+  let has_prompt_tool_change = false;
+
+  const fieldsToCompare = [
+    ...TOOL_SCHEMA_FIELDS,
+    "supports_image_detail_original",
+    "prompt_tool_mentions",
+  ];
+
+  for (const [slug, prevCfg] of prevBySlug) {
+    const currCfg = currBySlug.get(slug);
+    if (!currCfg) continue;
+    for (const field of fieldsToCompare) {
+      const p = (prevCfg as unknown as Record<string, unknown>)[field];
+      const c = (currCfg as unknown as Record<string, unknown>)[field];
+      if (!equal(p, c)) {
+        field_deltas.push({ slug, field, previous: p, current: c });
+        if (TOOL_SCHEMA_FIELDS.has(field)) has_tool_schema_change = true;
+        if (field === "prompt_tool_mentions") has_prompt_tool_change = true;
+      }
+    }
+  }
+
+  return {
+    added_models,
+    removed_models,
+    field_deltas,
+    has_tool_schema_change,
+    has_prompt_tool_change,
+  };
+}
+
+export type Verdict =
+  | "no-op"
+  | "prompt-only update"
+  | "tool-schema update needed"
+  | "tool-surface review needed"
+  | "manual review required";
+
+export interface VerdictInput {
+  models_diff: ModelsDiff | null;
+  prompt_md_changed: boolean;
+  tools_dir_changed: boolean;
+  apply_patch_dir_changed: boolean;
+  parse_error: boolean;
+}
+
+/** Decide which verdict best describes the upstream change set. */
+export function decideVerdict(input: VerdictInput): Verdict {
+  if (input.parse_error) return "manual review required";
+  if (!input.models_diff) return "manual review required";
+
+  const removedModels = input.models_diff.removed_models.length > 0;
+  if (removedModels) return "manual review required";
+
+  if (input.models_diff.has_tool_schema_change) {
+    return "tool-schema update needed";
+  }
+
+  if (input.tools_dir_changed || input.apply_patch_dir_changed) {
+    return "tool-surface review needed";
+  }
+
+  if (input.models_diff.has_prompt_tool_change || input.prompt_md_changed) {
+    return "prompt-only update";
+  }
+
+  if (input.models_diff.field_deltas.length > 0) {
+    return "prompt-only update";
+  }
+
+  return "no-op";
+}

package/scripts/codex-watch/render-issue.ts

@@ -0,0 +1,273 @@
+/**
+ * Renders a GitHub issue body summarizing a Codex release's impact on the
+ * letta-code harness.
+ */
+
+import type { ModelsDiff, Verdict } from "./diff-models-json.ts";
+
+const ACTION_REVIEWERS = ["@kl2806", "@devanshrj"];
+
+export interface PathChangeSummary {
+  path: string;
+  /** One-line commit subjects under this path between the two refs. */
+  commits: string[];
+}
+
+export interface RenderInput {
+  previous_tag: string;
+  current_tag: string;
+  release_url: string;
+  release_notes_md: string;
+  verdict: Verdict;
+  models_diff: ModelsDiff | null;
+  prompt_md_changed: boolean;
+  prompt_md_diff_preview: string | null;
+  path_changes: PathChangeSummary[];
+  workflow_run_url: string;
+}
+
+/** Mapping from upstream concept to local letta-code file(s) to inspect. */
+const LOCAL_MIRRORS: Record<string, string[]> = {
+  apply_patch_tool_type: [
+    "src/agent/prompts/source_codex.md",
+    "src/tools/impl/",
+    "src/tools/schemas/ApplyPatch.json",
+    "src/tools/descriptions/ApplyPatch.md",
+  ],
+  web_search_tool_type: ["src/tools/toolDefinitions.ts", "src/tools/impl/"],
+  shell_type: [
+    "src/tools/toolDefinitions.ts",
+    "src/tools/schemas/ShellCommand.json",
+    "src/tools/descriptions/ShellCommand.md",
+    "src/tools/impl/",
+    "src/agent/prompts/source_codex.md",
+  ],
+  supports_search_tool: ["src/tools/filter.ts", "src/tools/toolDefinitions.ts"],
+  supports_parallel_tool_calls: ["src/agent/prompts/source_codex.md"],
+  experimental_supported_tools: [
+    "src/tools/toolDefinitions.ts",
+    "src/tools/schemas/",
+    "src/tools/descriptions/",
+    "src/tools/impl/",
+  ],
+  input_modalities: ["src/tools/toolDefinitions.ts", "src/tools/impl/"],
+  truncation_policy: ["src/agent/prompts/source_codex.md"],
+  prompt_tool_mentions: ["src/agent/prompts/source_codex.md"],
+};
+
+function localMirror(field: string): string {
+  const mirrors = LOCAL_MIRRORS[field];
+  if (!mirrors || mirrors.length === 0) return "—";
+  return mirrors.join(", ");
+}
+
+function fmtVal(v: unknown): string {
+  if (v === undefined) return "_(unset)_";
+  if (v === null) return "`null`";
+  const s = JSON.stringify(v);
+  return s.length > 80 ? `\`${s.slice(0, 77)}...\`` : `\`${s}\``;
+}
+
+export function renderTitle(input: RenderInput): string {
+  return `[codex-watch] openai/codex ${input.current_tag} — ${input.verdict}`;
+}
+
+export function renderBody(input: RenderInput): string {
+  const parts: string[] = [];
+
+  // Verdict
+  parts.push(`## Verdict`);
+  parts.push("");
+  parts.push(`**${input.verdict}**`);
+  parts.push("");
+  parts.push(verdictRationale(input));
+  parts.push("");
+  if (needsReviewerAttention(input)) {
+    parts.push(`Reviewers: ${ACTION_REVIEWERS.join(" ")}`);
+    parts.push("");
+  }
+
+  // Tool / schema deltas
+  parts.push(`## Tool / schema deltas`);
+  parts.push("");
+  if (
+    input.models_diff &&
+    (input.models_diff.field_deltas.length > 0 ||
+      input.models_diff.added_models.length > 0 ||
+      input.models_diff.removed_models.length > 0)
+  ) {
+    if (input.models_diff.added_models.length > 0) {
+      parts.push(
+        `**Added models:** ${input.models_diff.added_models.map((s) => `\`${s}\``).join(", ")}`,
+      );
+      parts.push("");
+    }
+    if (input.models_diff.removed_models.length > 0) {
+      parts.push(
+        `**Removed models:** ${input.models_diff.removed_models.map((s) => `\`${s}\``).join(", ")}`,
+      );
+      parts.push("");
+    }
+    if (input.models_diff.field_deltas.length > 0) {
+      parts.push(
+        "| Model | Field | Previous | New | Affected letta-code path |",
+      );
+      parts.push(
+        "|-------|-------|----------|-----|--------------------------|",
+      );
+      for (const d of input.models_diff.field_deltas) {
+        parts.push(
+          `| \`${d.slug}\` | \`${d.field}\` | ${fmtVal(d.previous)} | ${fmtVal(d.current)} | ${localMirror(d.field)} |`,
+        );
+      }
+      parts.push("");
+    }
+  } else {
+    parts.push("_No tool-field deltas detected in `models.json`._");
+    parts.push("");
+  }
+
+  // Upstream changes by path
+  parts.push(`## Upstream changes by path`);
+  parts.push("");
+  if (input.path_changes.length > 0) {
+    for (const p of input.path_changes) {
+      parts.push(`### \`${p.path}\``);
+      if (p.commits.length === 0) {
+        parts.push("_No commits touching this path between releases._");
+      } else {
+        for (const c of p.commits) parts.push(`- ${c}`);
+      }
+      parts.push("");
+    }
+  } else {
+    parts.push("_No changes under watched paths._");
+    parts.push("");
+  }
+
+  const impacts = potentialImpacts(input);
+  if (impacts.length > 0) {
+    parts.push(`## Potential letta-code impact`);
+    parts.push("");
+    for (const impact of impacts) parts.push(`- ${impact}`);
+    parts.push("");
+  }
+
+  // Prompt diff preview
+  if (input.prompt_md_changed && input.prompt_md_diff_preview) {
+    parts.push(`## \`codex-rs/models-manager/prompt.md\` diff (preview)`);
+    parts.push("");
+    parts.push("```diff");
+    parts.push(input.prompt_md_diff_preview);
+    parts.push("```");
+    parts.push("");
+  }
+
+  // Suggested actions
+  parts.push(`## Suggested actions`);
+  parts.push("");
+  for (const a of suggestedActions(input)) parts.push(`- [ ] ${a}`);
+  parts.push("");
+
+  // Provenance
+  parts.push(`## How this was generated`);
+  parts.push("");
+  parts.push(`- Release/notes: ${input.release_url}`);
+  parts.push(
+    `- Compare: https://github.com/openai/codex/compare/${input.previous_tag}...${input.current_tag}`,
+  );
+  parts.push(`- Workflow run: ${input.workflow_run_url}`);
+
+  return parts.join("\n");
+}
+
+function needsReviewerAttention(input: RenderInput): boolean {
+  return input.verdict !== "no-op";
+}
+
+function verdictRationale(input: RenderInput): string {
+  switch (input.verdict) {
+    case "no-op":
+      return "No watched tool-surface changes detected.";
+    case "prompt-only update":
+      return "Prompt text or tool mentions changed; `src/agent/prompts/source_codex.md` may need re-extraction.";
+    case "tool-schema update needed":
+      return "Upstream changed tool-config fields in `models.json`. Review local mirrors only where the model contract changed.";
+    case "tool-surface review needed":
+      return "No `models.json` tool-field deltas, but upstream tool implementation paths changed. Check whether letta-code has a mirror.";
+    case "manual review required":
+      return "Could not classify automatically; review the upstream diff manually.";
+  }
+}
+
+function hasPath(input: RenderInput, prefix: string): boolean {
+  return input.path_changes.some((p) => p.path.startsWith(prefix));
+}
+
+function potentialImpacts(input: RenderInput): string[] {
+  const out: string[] = [];
+
+  if (input.models_diff?.field_deltas.length) {
+    out.push(
+      "`models.json` field deltas: inspect listed local mirrors for schema, availability, or prompt drift.",
+    );
+  }
+
+  if (hasPath(input, "codex-rs/core/src/tools")) {
+    out.push(
+      "Core tools changed: compare relevant commits against `src/tools/toolDefinitions.ts`, `schemas/`, `descriptions/`, `impl/`, and `manager.ts`.",
+    );
+    out.push(
+      "Likely mirrors: `view_image` → `ViewImage`, shell/exec → `ShellCommand`/`Bash`, `apply_patch` → `ApplyPatch`; MCP/search/approval may be upstream-only.",
+    );
+  }
+
+  if (hasPath(input, "codex-rs/apply-patch")) {
+    out.push(
+      "`apply-patch` changed: compare parser/failure semantics with `ApplyPatch.ts`, `MemoryApplyPatch.ts`, descriptions, and tests.",
+    );
+  }
+
+  if (input.prompt_md_changed) {
+    out.push(
+      "Prompt changed: reconcile `src/agent/prompts/source_codex.md` and README provenance.",
+    );
+  }
+
+  if (input.verdict === "no-op") {
+    out.push(
+      "No watched tool surfaces changed. Skim release notes, then close if nothing applies.",
+    );
+  }
+
+  return out;
+}
+
+function suggestedActions(input: RenderInput): string[] {
+  const out: string[] = [];
+  if (input.verdict === "no-op") {
+    out.push("Skim release notes; close if nothing stands out.");
+    return out;
+  }
+  if (input.verdict === "prompt-only update" || input.prompt_md_changed) {
+    out.push(
+      "Re-extract/reconcile `src/agent/prompts/source_codex.md` if prompt semantics changed.",
+    );
+  }
+  if (input.verdict === "tool-schema update needed") {
+    out.push(
+      "Inspect each `models.json` delta; update local schema/description/impl/tests only if the exposed contract changed.",
+    );
+  }
+  if (input.verdict === "tool-surface review needed") {
+    out.push(
+      "Review watched-path commits; if a change has a letta-code mirror, update schema/description/impl/prompt/tests together.",
+    );
+  }
+  if (input.verdict === "manual review required") {
+    out.push(
+      "Diff `openai/codex` between the two tags manually and decide whether letta-code needs to react.",
+    );
+  }
+  return out;
+}

package/scripts/rename-to-kebab.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+/**
+ * Renames all camelCase/PascalCase .ts files in src/ to kebab-case.
+ * .tsx files are skipped — PascalCase is correct for React components.
+ * .d.ts files are skipped.
+ * Runs git mv to preserve history.
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+function toKebab(s) {
+  return s
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+    .toLowerCase();
+}
+
+function* walkTs(dir) {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) {
+      yield* walkTs(full);
+    } else if (entry.endsWith(".ts") && !entry.endsWith(".d.ts")) {
+      yield full;
+    }
+  }
+}
+
+const renames = [];
+
+for (const file of walkTs("src")) {
+  const dir = dirname(file);
+  const filename = basename(file);
+  // Split on first dot to handle e.g. "FooBar.test.ts"
+  const dotIdx = filename.indexOf(".");
+  const base = filename.slice(0, dotIdx);
+  const ext = filename.slice(dotIdx); // e.g. ".ts" or ".test.ts"
+  const kebab = toKebab(base);
+  if (kebab !== base) {
+    const newFilename = kebab + ext;
+    const newFile = join(dir, newFilename);
+    renames.push({ from: file, to: newFile });
+  }
+}
+
+console.log(`Found ${renames.length} files to rename.\n`);
+
+for (const { from, to } of renames) {
+  if (existsSync(to)) {
+    console.warn(`SKIP (target exists): ${from} -> ${to}`);
+    continue;
+  }
+  execSync(`git mv "${from}" "${to}"`, { stdio: "inherit" });
+}
+
+console.log(`\nDone. ${renames.length} files renamed.`);
+console.log("\nNext: run the import update script to fix all references.");

package/scripts/run-unit-tests.cjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+const { execSync } = require("node:child_process");
+const { readdirSync, statSync } = require("node:fs");
+const path = require("node:path");
+
+// Unit test directories — bun discovers *.test.ts / *.test.tsx within each.
+// Listed explicitly so we skip src/integration-tests (API-gated) and avoid
+// shell expansion that can exceed the Windows command-line length limit.
+const dirs = [
+  "src/agent",
+  "src/auth",
+  "src/backend",
+  "src/cli",
+  "src/cron",
+  "src/experiments",
+  "src/hooks",
+  "src/lsp",
+  "src/permissions",
+  "src/providers",
+  "src/queue",
+  "src/ralph",
+  "src/reminders",
+  "src/skills",
+  "src/telemetry",
+  "src/test-utils",
+  "src/tools",
+  "src/types",
+  "src/updater",
+  "src/utils",
+  "src/websocket",
+  // Root-level test files (not inside a subdirectory)
+  "src/*.test.ts",
+];
+
+// slack-media.test.ts imports the real ./slack/media module. slack-adapter.test.ts
+// calls mock.module("./slack/media") which in Bun 1.3.x poisons the shared module
+// registry across parallel workers. We run slack-media in an isolated process first,
+// then run src/channels with all OTHER test files (excluding slack-media).
+function findTestFiles(dir, exclude) {
+  const results = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findTestFiles(full, exclude));
+    } else if (
+      (entry.name.endsWith(".test.ts") || entry.name.endsWith(".test.tsx")) &&
+      !exclude.includes(full.replace(/\\/g, "/"))
+    ) {
+      results.push(full.replace(/\\/g, "/"));
+    }
+  }
+  return results;
+}
+
+const channelTestFiles = findTestFiles("src/channels", [
+  "src/channels/slack-media.test.ts",
+]);
+
+const opts = { stdio: "inherit", shell: process.platform === "win32" };
+let exitCode = 0;
+
+// Run slack-media in isolation first (clean module registry)
+try {
+  execSync("bun test src/channels/slack-media.test.ts --timeout 15000", opts);
+} catch (e) {
+  exitCode = e.status ?? 1;
+}
+
+// Run everything else
+try {
+  execSync(
+    `bun test ${[...dirs, ...channelTestFiles].join(" ")} --timeout 15000`,
+    opts,
+  );
+} catch (e) {
+  exitCode = e.status ?? 1;
+}
+
+process.exit(exitCode);