@letta-ai/letta-code 0.32.7 → 0.32.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.32.7",
+  "version": "0.32.8",
   "lettaStartupLogProtocol": 1,
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",

package/scripts/run-unit-tests.cjs

@@ -2,6 +2,7 @@
 const { execFileSync } = require("node:child_process");
 const { readFileSync, readdirSync } = require("node:fs");
 const path = require("node:path");
+const { shardTestFiles } = require("./test-sharding.cjs");
 const {
   buildFamilyImpactIndex,
   getGitChangedFiles,
@@ -77,6 +78,7 @@ const allTestFiles = [
   ...findTestFiles("scripts/codex-watch"),
   ...findTestFiles("scripts/claude-watch"),
   "scripts/unit-test-impact.test.cjs",
+  "scripts/test-sharding.test.cjs",
 ].sort();
 const discoveredPaths = new Set(allTestFiles);
 
@@ -192,7 +194,15 @@ function selectTestFiles() {
 }
 
 let exitCode = 0;
-const selectedTestFiles = selectTestFiles();
+const shardIndex = process.argv.indexOf("--shard");
+const shard = shardIndex === -1 ? undefined : (process.argv[shardIndex + 1] ?? "");
+// Validate outside selection's full-suite fallback: an invalid shard must fail,
+// not make several jobs duplicate the entire suite or silently run nothing.
+shardTestFiles([], shard);
+const selectedTestFiles = shardTestFiles(selectTestFiles(), shard);
+if (shard) {
+  console.log(`unit-test shard ${shard}: ${selectedTestFiles.length} files`);
+}
 const selectedTestPaths = new Set(selectedTestFiles);
 
 // Bun module mocks and process-global state are shared within one test process.

package/scripts/source-file-size-baseline.json

@@ -38,10 +38,10 @@
   "src/tools/manager.ts": 2897,
   "src/tools/tool-execution-context.test.ts": 1136,
   "src/types/protocol_v2.ts": 2595,
-  "src/websocket/listen-client-concurrency.test.ts": 2683,
+  "src/websocket/listen-client-concurrency.test.ts": 2677,
   "src/websocket/listen-client-protocol.test.ts": 5762,
   "src/websocket/listener/commands/memory.ts": 1114,
   "src/websocket/listener/file-commands.ts": 1053,
   "src/websocket/listener/protocol-inbound.ts": 2143,
-  "src/websocket/listener/protocol-outbound.ts": 1025
+  "src/websocket/listener/protocol-outbound.ts": 1022
 }

package/scripts/test-sharding.cjs

@@ -0,0 +1,16 @@
+// Assign files before launching Bun, including suites that need their own
+// process. Sharding each Bun invocation separately would duplicate or omit
+// isolated suites. Keep file order within each shard unchanged.
+function shardTestFiles(files, shard) {
+  if (shard === undefined) return files;
+  if (!/^[1-9]\d*\/[1-9]\d*$/u.test(shard)) {
+    throw new Error("Expected --shard INDEX/COUNT, with 1 <= INDEX <= COUNT");
+  }
+  const [index, count] = shard.split("/").map(Number);
+  if (!Number.isSafeInteger(count) || index > count) {
+    throw new Error("Expected --shard INDEX/COUNT, with 1 <= INDEX <= COUNT");
+  }
+  return files.filter((_, position) => position % count === index - 1);
+}
+
+module.exports = { shardTestFiles };

package/scripts/test-sharding.test.cjs

@@ -0,0 +1,37 @@
+const { describe, expect, test } = require("bun:test");
+const { shardTestFiles } = require("./test-sharding.cjs");
+const { tests: isolated } = require("./isolated-unit-tests.json");
+
+describe("unit test sharding", () => {
+  const files = [
+    ...isolated.map(({ path }) => path),
+    ...Array.from({ length: 103 }, (_, i) => `src/tools/file-${i}.test.ts`),
+  ].sort();
+
+  test.each([1, 4, 8, 200])("%i shards cover every file exactly once", (count) => {
+    const shards = Array.from({ length: count }, (_, i) =>
+      shardTestFiles(files, `${i + 1}/${count}`),
+    );
+    expect(shards.flat().sort()).toEqual(files);
+    expect(new Set(shards.flat()).size).toBe(files.length);
+    for (const shard of shards) {
+      expect(shard).toEqual(files.filter((file) => shard.includes(file)));
+    }
+  });
+
+  test("selection stays empty rather than expanding into all tests", () => {
+    expect(shardTestFiles([], "1/8")).toEqual([]);
+    expect(shardTestFiles([files[0]], "8/8")).toEqual([]);
+  });
+
+  test("local runs without a shard preserve the full selection", () => {
+    expect(shardTestFiles(files)).toEqual(files);
+  });
+
+  test.each(["", "0/4", "1/0", "5/4", "-1/4", "1.5/4", "1/2/3", "1/Infinity"])(
+    "rejects invalid shard %s rather than silently dropping coverage",
+    (shard) => {
+      expect(() => shardTestFiles(files, shard)).toThrow("Expected --shard");
+    },
+  );
+});

package/scripts/unit-test-impact.cjs

@@ -527,14 +527,22 @@ function getGitChangedFiles(baseSha, headSha, rootDir = process.cwd()) {
     });
 }
 
-function readPullRequestShas(eventPath) {
+function readPullRequestShas(eventPath, rootDir = process.cwd()) {
   const event = JSON.parse(readFileSync(eventPath, "utf8"));
-  const baseSha = event.pull_request?.base?.sha;
-  const headSha =
-    event.pull_request?.merge_commit_sha ?? event.pull_request?.head?.sha;
-  if (typeof baseSha !== "string" || typeof headSha !== "string") {
-    throw new Error("Pull request event is missing base/head SHAs");
+  if (!event.pull_request) {
+    throw new Error("Expected a pull request event");
   }
+  // GitHub can enqueue an event whose merge_commit_sha differs from the merge
+  // actions/checkout fetches. Compare the tested tree with its own base parent;
+  // both are present at fetch-depth: 2. Requiring HEAD^2 also rejects a checkout
+  // of a branch head, so the caller safely runs everything in that case.
+  const [baseSha, , headSha] = execFileSync(
+    "git",
+    ["rev-parse", "HEAD^1", "HEAD^2", "HEAD"],
+    { cwd: rootDir, encoding: "utf8" },
+  )
+    .trim()
+    .split(/\r?\n/u);
   return { baseSha, headSha };
 }
 

package/scripts/unit-test-impact.test.cjs

@@ -1,10 +1,13 @@
 const { describe, expect, test } = require("bun:test");
+const { execFileSync } = require("node:child_process");
 const { mkdtempSync, rmSync, writeFileSync } = require("node:fs");
 const { tmpdir } = require("node:os");
 const { join } = require("node:path");
+const { pathToFileURL } = require("node:url");
 const {
   ROOT_FAMILY,
   buildFamilyImpactIndex,
+  getGitChangedFiles,
   planUnitTests,
   readPullRequestShas,
 } = require("./unit-test-impact.cjs");
@@ -233,29 +236,58 @@ describe("unit-test impact planning", () => {
     expect(result.reason).toBe("no changed files were provided");
   });
 
-  test("pull request selection compares the base with the tested merge tree", () => {
+  test("selection uses the shallow checkout when the event names a stale merge", () => {
     const directory = mkdtempSync(join(tmpdir(), "unit-impact-event-"));
     const eventPath = join(directory, "event.json");
+    const checkout = join(directory, "checkout");
+    const git = (...args) =>
+      execFileSync("git", args, {
+        cwd: directory,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          GIT_AUTHOR_NAME: "Test",
+          GIT_AUTHOR_EMAIL: "test@example.com",
+          GIT_COMMITTER_NAME: "Test",
+          GIT_COMMITTER_EMAIL: "test@example.com",
+        },
+      }).trim();
     try {
+      git("init", "-b", "main");
+      writeFileSync(join(directory, "base.txt"), "base");
+      git("add", "base.txt");
+      git("-c", "core.hooksPath=", "commit", "-m", "base");
+      const baseSha = git("rev-parse", "HEAD");
+      git("checkout", "-b", "feature");
+      writeFileSync(join(directory, "changed.txt"), "feature");
+      git("add", "changed.txt");
+      git("-c", "core.hooksPath=", "commit", "-m", "feature");
+      const branchHead = git("rev-parse", "HEAD");
+      git("checkout", "main");
+      git("-c", "core.hooksPath=", "merge", "--no-ff", "feature", "-m", "merge");
+      const headSha = git("rev-parse", "HEAD");
+      git("clone", "--depth=2", pathToFileURL(directory).href, checkout);
       writeFileSync(
         eventPath,
         JSON.stringify({
           pull_request: {
-            base: { sha: "base-sha" },
-            head: { sha: "branch-head-sha" },
-            merge_commit_sha: "tested-merge-sha",
+            base: { sha: baseSha },
+            head: { sha: branchHead },
+            merge_commit_sha: "700fce0cf421cd048f810e40822d608d7c81a2bc",
           },
         }),
       );
 
-      expect(readPullRequestShas(eventPath)).toEqual({
-        baseSha: "base-sha",
-        headSha: "tested-merge-sha",
-      });
+      const shas = readPullRequestShas(eventPath, checkout);
+      expect(shas).toEqual({ baseSha, headSha });
+      expect(getGitChangedFiles(shas.baseSha, shas.headSha, checkout)).toEqual([
+        { status: "A", path: "changed.txt", previousPath: undefined },
+      ]);
     } finally {
       rmSync(directory, { recursive: true, force: true });
     }
-  });
+  }, 30000);
 });
 
 describe("current repository impact graph", () => {

package/skills/working-across-computers/SKILL.md

@@ -1,10 +1,14 @@
 ---
 name: working-across-computers
-description: Guides work across Cloud, local, and other available computers, including teleporting the current conversation, orchestrating remote subagents, and uploading or downloading files to Cloud sandboxes. Use when moving between computers (e.g. teleporting between cloud/local) or coordinating work and files across them.
+description: Guides work across Cloud, local, and other available computers, including teleporting conversations, running remote subagents, and transferring files. Load when a request needs the user's laptop or another machine's files, apps, or tools; when connecting a computer; or when moving or delegating work between local and Cloud in either direction, including running Cloud subagents from local.
 ---
 
 # Working Across Computers
 
+## Discover access before declaring a limitation
+
+The current filesystem is not the full set of computers you can use. When a request needs another computer, run `letta teleport list`. If a suitable computer is available, delegate there; otherwise follow the [connection instructions](references/connect-a-computer-for-remote-access.md). Do not infer that another computer is inaccessible merely because you are running in Cloud.
+
 ## Choose where to work
 
 - When running in Cloud, prefer staying there and delegating local work to subagents on the relevant computer.