@letta-ai/letta-code 0.25.10 → 0.26.0

package/scripts/update-kebab-imports.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+/**
+ * Updates import paths after renaming .ts files to kebab-case.
+ *
+ * Builds an exact old-basename → new-basename mapping from `git diff --cached`
+ * so only paths that were actually renamed get updated.
+ * .tsx component imports are NOT touched (those files weren't renamed).
+ */
+
+import { execSync } from "node:child_process";
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+// Build exact mapping from git staged renames: oldBase -> newBase (no extension)
+const renameMap = new Map(); // "OldName" -> "new-name"
+
+const gitStatus = execSync("git diff --cached --name-status", {
+  encoding: "utf-8",
+});
+
+for (const line of gitStatus.split("\n")) {
+  const m = line.match(/^R\d*\t(.+)\t(.+)$/);
+  if (!m) continue;
+  const [, oldPath, newPath] = m;
+  const oldBase = basename(oldPath);
+  const newBase = basename(newPath);
+  if (oldBase === newBase) continue;
+
+  // Strip only the last extension (e.g. "FooBar.shared.ts" -> "FooBar.shared")
+  // so dotted names like imageResize.shared are looked up correctly.
+  const oldStem = oldBase.replace(/\.[^.]+$/, "");
+  const newStem = newBase.replace(/\.[^.]+$/, "");
+  renameMap.set(oldStem, newStem);
+}
+
+console.log(`Built rename map: ${renameMap.size} entries`);
+
+function* walkSrc(dir) {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) yield* walkSrc(full);
+    else if (entry.endsWith(".ts") || entry.endsWith(".tsx")) yield full;
+  }
+}
+
+// Replace the last path segment of an import path if it's in the rename map
+function updatePath(importPath) {
+  const lastSlash = importPath.lastIndexOf("/");
+  const dir = lastSlash >= 0 ? importPath.slice(0, lastSlash + 1) : "";
+  let file = lastSlash >= 0 ? importPath.slice(lastSlash + 1) : importPath;
+
+  // Strip explicit .ts/.js extension for lookup (imports usually have no ext)
+  let ext = "";
+  if (file.endsWith(".ts") || file.endsWith(".js")) {
+    ext = file.slice(file.lastIndexOf("."));
+    file = file.slice(0, file.lastIndexOf("."));
+  }
+
+  const newFile = renameMap.get(file);
+  if (!newFile) return importPath;
+  return dir + newFile + ext;
+}
+
+let totalFiles = 0;
+let totalChanged = 0;
+
+// Matches from/import()/require() string literals and new URL() path strings
+const IMPORT_RE =
+  /(?:(?:from|import)\s*\(?\s*|require\s*\()(["'`])([^"'`\n]+)\1/g;
+const URL_RE = /new\s+URL\s*\(\s*(["'`])([^"'`\n]+\.ts)\1/g;
+
+for (const file of walkSrc("src")) {
+  const src = readFileSync(file, "utf-8");
+  let result = src;
+
+  result = result.replace(IMPORT_RE, (match, quote, path) => {
+    const updated = updatePath(path);
+    return updated === path ? match : match.replace(path, updated);
+  });
+
+  result = result.replace(URL_RE, (match, quote, path) => {
+    const updated = updatePath(path);
+    return updated === path ? match : match.replace(path, updated);
+  });
+
+  if (result !== src) {
+    writeFileSync(file, result, "utf-8");
+    totalChanged++;
+  }
+  totalFiles++;
+}
+
+console.log(`Scanned ${totalFiles} files, updated ${totalChanged} files.`);

package/skills/initializing-memory/SKILL.md

@@ -50,7 +50,7 @@ You should determine what the users goals and motivations are, to help yourself
 Understanding the user's personality and other attributes about them will help contextualize their interactions and allow you to engage with them more effectively. Can you pattern match them to common personas? Do they have unique attributes, quirks, or linguistic patterns? How would you describe them as a person? 
 
 **Understanding their preferences**: 
-You should learn how the user wants work to be done, and how they want to collaborate with AIs like yourself. Examples of this can include coding preferences (e.g. "Prefer functional components over class components", "Use early returns instead of nested conditionals"), but also higher-level preferences such as when to use plan mode, the scope of changes, how to communicate in different scenarios, etc. 
+You should learn how the user wants work to be done, and how they want to collaborate with AIs like yourself. Examples of this can include coding preferences (e.g. "Prefer functional components over class components", "Use early returns instead of nested conditionals"), but also higher-level preferences such as when to ask before planning or implementing, the scope of changes, how to communicate in different scenarios, etc.
 
 ### Understanding the codebase and existing work
 You should also learn as much as possible about the existing codebase and work. Think of this as your onboarding period - an opportunity to maximize your performance for future tasks. Learn things like: 
@@ -718,4 +718,3 @@ git push
 **Write findings to memory as you go** — don't wait until the end.
 **Edit memory files directly via the filesystem** — memory is projected to `$MEMORY_DIR` specifically for ease of bulk modification. Use standard file tools (Read, Write, Edit) and git to manage changes during initialization.
 
-

package/skills/working-in-parallel/SKILL.md

@@ -1,90 +0,0 @@
----
-name: working-in-parallel
-description: Guide for working in parallel with other agents. Use when another agent is already working in the same directory, or when you need to work on multiple features simultaneously. Covers git worktrees as the recommended approach.
----
-
-# Working in Parallel
-
-Use **git worktrees** to work in parallel when another agent is in the same directory.
-
-Git worktrees let you check out multiple branches into separate directories. Each worktree has its own isolated files while sharing the same Git history and remote connections. Changes in one worktree won't affect others, so parallel agents can't interfere with each other.
-
-Learn more: [Git worktree documentation](https://git-scm.com/docs/git-worktree)
-
-## IMPORTANT: Worktree Location
-
-**All worktrees MUST be created under `.letta/worktrees/` in the repo root.** This keeps worktrees organized, gitignored, and out of the user's project directory.
-
-Before creating the first worktree, ensure `.letta/worktrees` is in the repo's `.gitignore`:
-
-```bash
-# Add to .gitignore if not already present
-grep -q '.letta/worktrees' .gitignore 2>/dev/null || echo '.letta/worktrees' >> .gitignore
-```
-
-## IMPORTANT: Check Project Setup First
-
-Before running ANY commands in a new worktree, check the project's setup instructions:
-
-1. **Read the README** - Usually has install/build commands
-2. **Check `claude.md` or `AGENT.md`** - Agent-specific guidance if present
-3. **Review your `project` memory block** - Contains learned project preferences
-
-Don't assume `npm` vs `bun` vs `pnpm` - **check the project first!**
-
-## Quick Start
-
-```bash
-# Ensure .letta/worktrees is gitignored
-grep -q '.letta/worktrees' .gitignore 2>/dev/null || echo '.letta/worktrees' >> .gitignore
-
-# Create worktree with new branch (from repo root)
-git worktree add -b fix/my-feature .letta/worktrees/my-feature main
-
-# Work in the worktree
-cd .letta/worktrees/my-feature
-
-# CHECK PROJECT SETUP FIRST - then install dependencies
-# Read README.md or check project memory block for correct command
-bun install  # Example - verify this is correct for YOUR project!
-
-# Make changes, commit, push, PR
-git add <files>
-git commit -m "fix: description"
-git push -u origin fix/my-feature
-gh pr create --title "Fix: description" --body "## Summary..."
-
-# Clean up when done (from repo root)
-git worktree remove .letta/worktrees/my-feature
-```
-
-## Key Commands
-
-```bash
-git worktree add -b <branch> .letta/worktrees/<name> main  # Create with new branch
-git worktree add .letta/worktrees/<name> <existing-branch>  # Use existing branch
-git worktree list                                            # Show all worktrees
-git worktree remove .letta/worktrees/<name>                  # Remove worktree
-```
-
-## When to Use
-
-- Another agent is working in the current directory
-- Long-running task in one session, quick fix needed in another
-- User wants to continue development while an agent works on a separate feature
-
-## Pre-commit Hooks in Worktrees
-
-Worktrees share `.git`, but pre-commit hooks may need initialization depending on project setup. After creating a worktree and installing dependencies, verify hooks are active before committing. Check project docs or run the project's hook setup command if needed.
-
-## Tips
-
-- **Always use `.letta/worktrees/`** - never create worktrees outside this directory
-- **Check project setup docs before installing** - README, claude.md, project memory block
-- Name worktrees clearly: `.letta/worktrees/feature-auth`, `.letta/worktrees/bugfix-123`
-- Install dependencies using the project's package manager (check first!)
-- Push changes before removing worktrees
-
-## Alternative: Repo Clones
-
-Some users prefer cloning the repo multiple times (`gh repo clone owner/repo project-01`) for simpler mental model. This uses more disk space but provides complete isolation. If the user expresses confusion about worktrees or explicitly prefers clones, use that approach instead.