@letta-ai/letta-code 0.27.30 → 0.28.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@letta-ai/letta-code",
-  "version": "0.27.30",
+  "version": "0.28.1",
   "description": "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
   "type": "module",
   "packageManager": "bun@1.3.0",
@@ -50,7 +50,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "^0.79.6",
+    "@earendil-works/pi-ai": "^0.80.6",
     "@letta-ai/letta-client": "^1.10.2",
     "@pierre/diffs": "1.2.2",
     "@scarf/scarf": "^1.4.0",
@@ -95,6 +95,8 @@
     "check:boundaries": "node scripts/check-layer-boundaries.js",
     "check:exported-functions": "node scripts/check-exported-functions.js",
     "check:filename-casing": "node scripts/check-filename-casing.js",
+    "check:file-size": "node scripts/check-source-file-size.js",
+    "check:module-ownership": "node scripts/check-module-ownership.js",
     "check:test-mock-isolation": "bun run scripts/check-test-mock-isolation.js",
     "check:test-coverage": "node scripts/check-test-coverage.cjs",
     "check:skill-frontmatter": "node scripts/check-skill-frontmatter.js",

package/scripts/check-module-ownership.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+
+import { readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+
+const RULES = [
+  {
+    module: "src/channels/slack/adapter.ts",
+    allowedImporters: new Set([
+      "src/channels/slack/adapter-test-harness.ts",
+      "src/channels/slack/plugin.ts",
+    ]),
+    forbidForwardingExports: true,
+  },
+];
+
+function findTypeScriptFiles(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const filePath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findTypeScriptFiles(filePath));
+    } else if (/\.tsx?$/.test(entry.name)) {
+      files.push(filePath.replace(/\\/g, "/"));
+    }
+  }
+  return files;
+}
+
+function resolveModule(importer, specifier) {
+  let candidate;
+  if (specifier.startsWith("@/")) {
+    candidate = path.join("src", specifier.slice(2));
+  } else if (specifier.startsWith(".")) {
+    candidate = path.join(path.dirname(importer), specifier);
+  } else {
+    return null;
+  }
+
+  const normalized = path.normalize(candidate).replace(/\\/g, "/");
+  const candidates = [normalized, `${normalized}.ts`, `${normalized}.tsx`];
+  return candidates.find((item) => ruleModules.has(item)) ?? null;
+}
+
+function parseTypeScript(filePath, source) {
+  const scriptKind = filePath.endsWith(".tsx")
+    ? ts.ScriptKind.TSX
+    : ts.ScriptKind.TS;
+  return ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.Latest,
+    false,
+    scriptKind,
+  );
+}
+
+function collectModuleSpecifiers(sourceFile) {
+  const specifiers = [];
+
+  function visit(node) {
+    if (
+      (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+      node.moduleSpecifier &&
+      ts.isStringLiteralLike(node.moduleSpecifier)
+    ) {
+      specifiers.push(node.moduleSpecifier.text);
+    } else if (
+      ts.isCallExpression(node) &&
+      node.arguments.length === 1 &&
+      ts.isStringLiteralLike(node.arguments[0]) &&
+      (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+        (ts.isIdentifier(node.expression) &&
+          node.expression.text === "require"))
+    ) {
+      specifiers.push(node.arguments[0].text);
+    }
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return specifiers;
+}
+
+const rulesByModule = new Map(RULES.map((rule) => [rule.module, rule]));
+const ruleModules = new Set(rulesByModule.keys());
+const files = findTypeScriptFiles("src");
+const failures = [];
+
+for (const importer of files) {
+  const source = readFileSync(importer, "utf8");
+  const sourceFile = parseTypeScript(importer, source);
+  for (const specifier of collectModuleSpecifiers(sourceFile)) {
+    const module = resolveModule(importer, specifier);
+    if (!module) continue;
+    const rule = rulesByModule.get(module);
+    if (importer !== module && !rule.allowedImporters.has(importer)) {
+      failures.push(
+        `${importer}: import ${specifier} from its owning module instead of ${module}`,
+      );
+    }
+  }
+}
+
+for (const rule of RULES) {
+  if (!rule.forbidForwardingExports) continue;
+  const source = readFileSync(rule.module, "utf8");
+  const sourceFile = parseTypeScript(rule.module, source);
+  const hasForwardingExport = sourceFile.statements.some(
+    (statement) =>
+      ts.isExportDeclaration(statement) && statement.moduleSpecifier,
+  );
+  if (hasForwardingExport) {
+    failures.push(
+      `${rule.module}: forwarding exports hide module ownership; import from the defining module`,
+    );
+  }
+}
+
+if (failures.length > 0) {
+  console.error("Module ownership check failed:\n");
+  for (const failure of failures) console.error(`  ${failure}`);
+  process.exit(1);
+}
+
+console.log(`Checked ${files.length} TypeScript files for module ownership`);

package/scripts/check-source-file-size.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+import { readdirSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+const MAX_LINES = 1000;
+const SOURCE_ROOTS = ["src", "scripts"];
+const SOURCE_EXTENSIONS = new Set([".cjs", ".js", ".jsx", ".ts", ".tsx"]);
+const BASELINE_PATH = "scripts/source-file-size-baseline.json";
+
+function findSourceFiles(dir) {
+  const files = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const filePath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findSourceFiles(filePath));
+    } else if (SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
+      files.push(filePath.replace(/\\/g, "/"));
+    }
+  }
+  return files;
+}
+
+function countLines(filePath) {
+  const text = readFileSync(filePath, "utf8");
+  if (text.length === 0) return 0;
+  const newlineCount = (text.match(/\n/g) ?? []).length;
+  return newlineCount + (text.endsWith("\n") ? 0 : 1);
+}
+
+const baseline = JSON.parse(readFileSync(BASELINE_PATH, "utf8"));
+const files = SOURCE_ROOTS.flatMap(findSourceFiles).sort();
+const counts = new Map(files.map((file) => [file, countLines(file)]));
+const failures = [];
+
+for (const [file, lines] of counts) {
+  const allowedLines = baseline[file];
+  if (lines <= MAX_LINES) {
+    if (allowedLines !== undefined) {
+      failures.push(
+        `${file}: now ${lines} lines; remove its obsolete baseline entry`,
+      );
+    }
+    continue;
+  }
+
+  if (allowedLines === undefined) {
+    failures.push(
+      `${file}: ${lines} lines exceeds the ${MAX_LINES}-line limit`,
+    );
+    continue;
+  }
+  if (lines > allowedLines) {
+    failures.push(
+      `${file}: grew from the ${allowedLines}-line baseline to ${lines} lines`,
+    );
+  } else if (lines < allowedLines) {
+    failures.push(
+      `${file}: shrank from ${allowedLines} to ${lines} lines; ratchet the baseline down`,
+    );
+  }
+}
+
+for (const file of Object.keys(baseline)) {
+  if (!counts.has(file)) {
+    failures.push(`${file}: baseline entry points to a missing source file`);
+  }
+}
+
+if (failures.length > 0) {
+  console.error("Source file size check failed:\n");
+  for (const failure of failures) console.error(`  ${failure}`);
+  console.error(
+    `\nNew source files must stay at or below ${MAX_LINES} lines. Split oversized files by responsibility; only lower or remove baseline entries.`,
+  );
+  process.exit(1);
+}
+
+console.log(
+  `Checked ${files.length} source files (maximum ${MAX_LINES} lines)`,
+);

package/scripts/check-test-mock-isolation.js

@@ -42,11 +42,6 @@ const COMPLETE_EXPORT_MOCK_MODULES = new Set([
 // add a file+module entry here in the same PR with a clear explanation.
 const ALLOWED_TOP_LEVEL_MOCKS = new Set([
   "src/channels/discord-registry.test.ts::../backend/api/client",
-  "src/channels/slack-adapter-interop.test.ts::./slack/media",
-  "src/channels/slack-adapter-interop.test.ts::./slack/runtime",
-  "src/channels/slack-adapter.test.ts::./slack/media",
-  "src/channels/slack-adapter.test.ts::./slack/runtime",
-  "src/channels/telegram-adapter.test.ts::./telegram/runtime",
   "src/cli/message-search-cache-warm.test.ts::../backend/api/search",
   "src/hooks/prompt-executor.test.ts::../backend/api/generate",
   "src/tools/memory-apply-patch.test.ts::../backend/api/client",

package/scripts/check.js

@@ -17,6 +17,8 @@ const checks = [
   { name: "layer boundaries", script: ["check:boundaries"] },
   { name: "exported function style", script: ["check:exported-functions"] },
   { name: "filename casing", script: ["check:filename-casing"] },
+  { name: "source file size", script: ["check:file-size"] },
+  { name: "module ownership", script: ["check:module-ownership"] },
   { name: "test mock isolation", script: ["check:test-mock-isolation"] },
   { name: "test coverage", script: ["check:test-coverage"] },
   { name: "skill frontmatter", script: ["check:skill-frontmatter"] },

package/scripts/run-unit-tests.cjs

@@ -34,10 +34,10 @@ const dirs = [
   "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).
+// slack/media.test.ts imports the real media module. The adapter test harness
+// mocks that module, which in Bun 1.3.x poisons the shared module registry
+// across parallel workers. Run media tests in an isolated process first, then
+// run src/channels with every other test file.
 function findTestFiles(dir, exclude) {
   const results = [];
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
@@ -55,15 +55,15 @@ function findTestFiles(dir, exclude) {
 }
 
 const channelTestFiles = findTestFiles("src/channels", [
-  "src/channels/slack-media.test.ts",
+  "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)
+// Run Slack media tests in isolation first (clean module registry)
 try {
-  execSync("bun test src/channels/slack-media.test.ts --timeout 15000", opts);
+  execSync("bun test src/channels/slack/media.test.ts --timeout 15000", opts);
 } catch (e) {
   exitCode = e.status ?? 1;
 }

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

@@ -0,0 +1,53 @@
+{
+  "src/agent/client-skills.test.ts": 1196,
+  "src/agent/memory-git.ts": 2324,
+  "src/agent/subagents/manager.ts": 1577,
+  "src/backend/local-backend.test.ts": 2589,
+  "src/backend/local/local-backend.ts": 1058,
+  "src/backend/local/local-store.ts": 3629,
+  "src/backend/pi-stream-adapter.test.ts": 1442,
+  "src/cli/app/AppCoordinator.tsx": 5198,
+  "src/cli/app/AppView.tsx": 1750,
+  "src/cli/app/use-approval-flow.ts": 1163,
+  "src/cli/app/use-configuration-handlers.ts": 1383,
+  "src/cli/app/use-conversation-loop.ts": 2935,
+  "src/cli/app/use-submit-handler.ts": 4100,
+  "src/cli/components/AgentSelector.tsx": 1270,
+  "src/cli/components/InputRich.tsx": 2219,
+  "src/cli/components/ModelSelector.tsx": 1204,
+  "src/cli/components/ProviderSelector.tsx": 1676,
+  "src/cli/components/ToolCallMessageRich.tsx": 1109,
+  "src/cli/helpers/accumulator.ts": 1596,
+  "src/cli/helpers/reflection-transcript.ts": 2080,
+  "src/cli/helpers/stream.ts": 1046,
+  "src/cli/mods/local-mod-loader.test.ts": 1043,
+  "src/cli/reflection-transcript.test.ts": 1118,
+  "src/cli/subcommands/skills.ts": 1264,
+  "src/headless.ts": 5238,
+  "src/hooks/integration.test.ts": 1147,
+  "src/index.ts": 2854,
+  "src/mods/learning-harness.ts": 2434,
+  "src/mods/mod-engine.test.ts": 2178,
+  "src/mods/mod-engine.ts": 1919,
+  "src/mods/package-installer.test.ts": 1248,
+  "src/mods/package-installer.ts": 1201,
+  "src/mods/package-registry.ts": 1033,
+  "src/permissions/read-only-shell.test.ts": 1303,
+  "src/permissions/read-only-shell.ts": 2009,
+  "src/providers/chatgpt-usage-service.ts": 1115,
+  "src/settings-manager.test.ts": 1669,
+  "src/settings-manager.ts": 2113,
+  "src/tools/impl/enter-worktree.ts": 1265,
+  "src/tools/impl/message-channel.ts": 1208,
+  "src/tools/manager.ts": 3293,
+  "src/tools/tool-execution-context.test.ts": 1422,
+  "src/types/protocol_v2.ts": 2932,
+  "src/websocket/listen-client-concurrency.test.ts": 3021,
+  "src/websocket/listen-client-protocol.test.ts": 6721,
+  "src/websocket/listener/commands/channels.ts": 1390,
+  "src/websocket/listener/commands/memory.ts": 1114,
+  "src/websocket/listener/file-commands.ts": 1030,
+  "src/websocket/listener/lifecycle.ts": 1766,
+  "src/websocket/listener/protocol-inbound.ts": 2279,
+  "src/websocket/listener/protocol-outbound.ts": 1279
+}