@letta-ai/letta-code 0.13.10 → 0.14.0

package/skills/syncing-memory-filesystem/scripts/memfs-status.ts

@@ -0,0 +1,354 @@
+#!/usr/bin/env npx tsx
+/**
+ * Memory Filesystem Status Check
+ *
+ * Read-only check of the current memFS sync status.
+ * Shows conflicts, pending changes, and overall sync health.
+ * Analogous to `git status`.
+ *
+ * Usage:
+ *   npx tsx memfs-status.ts <agent-id>
+ *
+ * Output: JSON object with sync status
+ */
+
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const require = createRequire(import.meta.url);
+const Letta = require("@letta-ai/letta-client")
+  .default as typeof import("@letta-ai/letta-client").default;
+
+function getApiKey(): string {
+  if (process.env.LETTA_API_KEY) {
+    return process.env.LETTA_API_KEY;
+  }
+
+  const settingsPath = join(homedir(), ".letta", "settings.json");
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    if (settings.env?.LETTA_API_KEY) {
+      return settings.env.LETTA_API_KEY;
+    }
+  } catch {
+    // Settings file doesn't exist or is invalid
+  }
+
+  throw new Error(
+    "No LETTA_API_KEY found. Set the env var or run the Letta CLI to authenticate.",
+  );
+}
+
+// We can't import checkMemoryFilesystemStatus directly since it relies on
+// getClient() which uses the CLI's auth chain. Instead, we reimplement the
+// status check logic using the standalone client pattern.
+// This keeps the script fully standalone and runnable outside the CLI process.
+
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import { relative } from "node:path";
+
+const MEMORY_FS_STATE_FILE = ".sync-state.json";
+
+type SyncState = {
+  systemBlocks: Record<string, string>;
+  systemFiles: Record<string, string>;
+  detachedBlocks: Record<string, string>;
+  detachedFiles: Record<string, string>;
+  detachedBlockIds: Record<string, string>;
+  lastSync: string | null;
+};
+
+function hashContent(content: string): string {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+function getMemoryRoot(agentId: string): string {
+  return join(homedir(), ".letta", "agents", agentId, "memory");
+}
+
+function loadSyncState(agentId: string): SyncState {
+  const statePath = join(getMemoryRoot(agentId), MEMORY_FS_STATE_FILE);
+  if (!existsSync(statePath)) {
+    return {
+      systemBlocks: {},
+      systemFiles: {},
+      detachedBlocks: {},
+      detachedFiles: {},
+      detachedBlockIds: {},
+      lastSync: null,
+    };
+  }
+
+  try {
+    const raw = readFileSync(statePath, "utf-8");
+    const parsed = JSON.parse(raw) as Partial<SyncState> & {
+      blocks?: Record<string, string>;
+      files?: Record<string, string>;
+    };
+    return {
+      systemBlocks: parsed.systemBlocks || parsed.blocks || {},
+      systemFiles: parsed.systemFiles || parsed.files || {},
+      detachedBlocks: parsed.detachedBlocks || {},
+      detachedFiles: parsed.detachedFiles || {},
+      detachedBlockIds: parsed.detachedBlockIds || {},
+      lastSync: parsed.lastSync || null,
+    };
+  } catch {
+    return {
+      systemBlocks: {},
+      systemFiles: {},
+      detachedBlocks: {},
+      detachedFiles: {},
+      detachedBlockIds: {},
+      lastSync: null,
+    };
+  }
+}
+
+async function scanMdFiles(dir: string, baseDir = dir): Promise<string[]> {
+  if (!existsSync(dir)) return [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  const results: string[] = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...(await scanMdFiles(fullPath, baseDir)));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      results.push(relative(baseDir, fullPath));
+    }
+  }
+  return results;
+}
+
+function labelFromPath(relativePath: string): string {
+  return relativePath.replace(/\\/g, "/").replace(/\.md$/, "");
+}
+
+async function readMemoryFiles(
+  dir: string,
+): Promise<Map<string, { content: string }>> {
+  const files = await scanMdFiles(dir);
+  const entries = new Map<string, { content: string }>();
+  for (const rel of files) {
+    const label = labelFromPath(rel);
+    const content = await readFile(join(dir, rel), "utf-8");
+    entries.set(label, { content });
+  }
+  return entries;
+}
+
+const MANAGED_LABELS = new Set([
+  "memory_filesystem",
+  "skills",
+  "loaded_skills",
+]);
+
+interface StatusResult {
+  conflicts: Array<{ label: string }>;
+  pendingFromFile: string[];
+  pendingFromBlock: string[];
+  newFiles: string[];
+  newBlocks: string[];
+  isClean: boolean;
+  lastSync: string | null;
+}
+
+async function checkStatus(agentId: string): Promise<StatusResult> {
+  const baseUrl = process.env.LETTA_BASE_URL || "https://api.letta.com";
+  const client = new Letta({ apiKey: getApiKey(), baseUrl });
+
+  const root = getMemoryRoot(agentId);
+  const systemDir = join(root, "system");
+  // Detached files go at root level (flat structure)
+  const detachedDir = root;
+
+  // Ensure directories exist
+  for (const dir of [root, systemDir]) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+
+  const systemFiles = await readMemoryFiles(systemDir);
+  const detachedFiles = await readMemoryFiles(detachedDir);
+  systemFiles.delete("memory_filesystem");
+
+  // Fetch attached blocks
+  const blocksResponse = await client.agents.blocks.list(agentId, {
+    limit: 1000,
+  });
+  const blocks = Array.isArray(blocksResponse)
+    ? blocksResponse
+    : ((blocksResponse as { items?: unknown[] }).items as Array<{
+        label?: string;
+        value?: string;
+      }>) || [];
+
+  const systemBlockMap = new Map(
+    blocks
+      .filter((b: { label?: string }) => b.label)
+      .map((b: { label?: string; value?: string }) => [
+        b.label as string,
+        b.value || "",
+      ]),
+  );
+  systemBlockMap.delete("memory_filesystem");
+
+  const lastState = loadSyncState(agentId);
+
+  const conflicts: Array<{ label: string }> = [];
+  const pendingFromFile: string[] = [];
+  const pendingFromBlock: string[] = [];
+  const newFiles: string[] = [];
+  const newBlocks: string[] = [];
+
+  // Fetch user blocks
+  const detachedBlockMap = new Map<string, string>();
+  for (const [label, blockId] of Object.entries(lastState.detachedBlockIds)) {
+    try {
+      const block = await client.blocks.retrieve(blockId);
+      detachedBlockMap.set(label, block.value || "");
+    } catch {
+      // Block no longer exists
+    }
+  }
+
+  function classify(
+    label: string,
+    fileContent: string | null,
+    blockValue: string | null,
+    lastFileHash: string | null,
+    lastBlockHash: string | null,
+  ) {
+    const fileHash = fileContent !== null ? hashContent(fileContent) : null;
+    const blockHash = blockValue !== null ? hashContent(blockValue) : null;
+    const fileChanged = fileHash !== lastFileHash;
+    const blockChanged = blockHash !== lastBlockHash;
+
+    if (fileContent !== null && blockValue === null) {
+      if (lastBlockHash && !fileChanged) return;
+      newFiles.push(label);
+      return;
+    }
+    if (fileContent === null && blockValue !== null) {
+      if (lastFileHash && !blockChanged) return;
+      newBlocks.push(label);
+      return;
+    }
+    if (fileContent === null || blockValue === null) return;
+    if (fileHash === blockHash) return;
+    if (fileChanged && blockChanged) {
+      conflicts.push({ label });
+      return;
+    }
+    if (fileChanged && !blockChanged) {
+      pendingFromFile.push(label);
+      return;
+    }
+    if (!fileChanged && blockChanged) {
+      pendingFromBlock.push(label);
+    }
+  }
+
+  // Check system labels
+  const systemLabels = new Set([
+    ...systemFiles.keys(),
+    ...systemBlockMap.keys(),
+    ...Object.keys(lastState.systemBlocks),
+    ...Object.keys(lastState.systemFiles),
+  ]);
+
+  for (const label of [...systemLabels].sort()) {
+    if (MANAGED_LABELS.has(label)) continue;
+    classify(
+      label,
+      systemFiles.get(label)?.content ?? null,
+      systemBlockMap.get(label) ?? null,
+      lastState.systemFiles[label] ?? null,
+      lastState.systemBlocks[label] ?? null,
+    );
+  }
+
+  // Check user labels
+  const userLabels = new Set([
+    ...detachedFiles.keys(),
+    ...detachedBlockMap.keys(),
+    ...Object.keys(lastState.detachedBlocks),
+    ...Object.keys(lastState.detachedFiles),
+  ]);
+
+  for (const label of [...userLabels].sort()) {
+    classify(
+      label,
+      detachedFiles.get(label)?.content ?? null,
+      detachedBlockMap.get(label) ?? null,
+      lastState.detachedFiles[label] ?? null,
+      lastState.detachedBlocks[label] ?? null,
+    );
+  }
+
+  const isClean =
+    conflicts.length === 0 &&
+    pendingFromFile.length === 0 &&
+    pendingFromBlock.length === 0 &&
+    newFiles.length === 0 &&
+    newBlocks.length === 0;
+
+  return {
+    conflicts,
+    pendingFromFile,
+    pendingFromBlock,
+    newFiles,
+    newBlocks,
+    isClean,
+    lastSync: lastState.lastSync,
+  };
+}
+
+// CLI Entry Point
+const isMainModule = import.meta.url === `file://${process.argv[1]}`;
+if (isMainModule) {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    console.log(`
+Usage: npx tsx memfs-status.ts <agent-id>
+
+Shows the current memFS sync status (read-only).
+Analogous to 'git status'.
+
+Arguments:
+  agent-id     Agent ID to check (can use $LETTA_AGENT_ID)
+
+Output: JSON object with:
+  - conflicts: blocks where both file and block changed
+  - pendingFromFile: file changed, block didn't
+  - pendingFromBlock: block changed, file didn't
+  - newFiles: file exists without a block
+  - newBlocks: block exists without a file
+  - isClean: true if everything is in sync
+  - lastSync: timestamp of last sync
+    `);
+    process.exit(0);
+  }
+
+  const agentId = args[0];
+  if (!agentId) {
+    console.error("Error: agent-id is required");
+    process.exit(1);
+  }
+
+  checkStatus(agentId)
+    .then((status) => {
+      console.log(JSON.stringify(status, null, 2));
+    })
+    .catch((error) => {
+      console.error(
+        "Error checking memFS status:",
+        error instanceof Error ? error.message : String(error),
+      );
+      process.exit(1);
+    });
+}

package/vendor/ink-text-input/build/index.js

@@ -74,7 +74,13 @@ function TextInput({ value: originalValue, placeholder = '', focus = true, mask,
         renderedValue = value.length > 0 ? '' : chalk.inverse(' ');
         let i = 0;
         for (const char of value) {
-            renderedValue += i >= cursorOffset - cursorActualWidth && i <= cursorOffset ? chalk.inverse(char) : char;
+            const isCursorPosition = i >= cursorOffset - cursorActualWidth && i <= cursorOffset;
+            if (isCursorPosition && char === '\n') {
+                // Newline at cursor: show inverted space (visible cursor) then the newline
+                renderedValue += chalk.inverse(' ') + char;
+            } else {
+                renderedValue += isCursorPosition ? chalk.inverse(char) : char;
+            }
             i++;
         }
         if (value.length > 0 && cursorOffset === value.length) {

package/skills/defragmenting-memory/scripts/backup-memory.ts

@@ -1,206 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * Backup Memory Blocks to Local Files
- *
- * Exports all memory blocks from an agent to local files for checkpointing and editing.
- * Creates a timestamped backup directory with:
- * - Individual .md files for each memory block
- * - manifest.json with metadata
- *
- * This script is standalone and can be run outside the CLI process.
- * It reads auth from LETTA_API_KEY env var or ~/.letta/settings.json.
- *
- * Usage:
- *   npx tsx backup-memory.ts <agent-id> [backup-dir]
- *
- * Example:
- *   npx tsx backup-memory.ts agent-abc123
- *   npx tsx backup-memory.ts $LETTA_AGENT_ID .letta/backups/working
- */
-
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { createRequire } from "node:module";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-// Use createRequire for @letta-ai/letta-client so NODE_PATH is respected
-// (ES module imports don't respect NODE_PATH, but require does)
-const require = createRequire(import.meta.url);
-const Letta = require("@letta-ai/letta-client")
-  .default as typeof import("@letta-ai/letta-client").default;
-type LettaClient = InstanceType<typeof Letta>;
-
-export interface BackupManifest {
-  agent_id: string;
-  timestamp: string;
-  backup_path: string;
-  blocks: Array<{
-    id: string;
-    label: string;
-    filename: string;
-    limit: number;
-    value_length: number;
-  }>;
-}
-
-/**
- * Get API key from env var or settings file
- */
-function getApiKey(): string {
-  if (process.env.LETTA_API_KEY) {
-    return process.env.LETTA_API_KEY;
-  }
-
-  const settingsPath = join(homedir(), ".letta", "settings.json");
-  try {
-    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    if (settings.env?.LETTA_API_KEY) {
-      return settings.env.LETTA_API_KEY;
-    }
-  } catch {
-    // Settings file doesn't exist or is invalid
-  }
-
-  throw new Error(
-    "No LETTA_API_KEY found. Set the env var or run the Letta CLI to authenticate.",
-  );
-}
-
-/**
- * Create a Letta client with auth from env/settings
- */
-function createClient(): LettaClient {
-  const baseUrl = process.env.LETTA_BASE_URL || "https://api.letta.com";
-  return new Letta({ apiKey: getApiKey(), baseUrl });
-}
-
-/**
- * Backup memory blocks to local files
- */
-async function backupMemory(
-  agentId: string,
-  backupDir?: string,
-): Promise<string> {
-  const client = createClient();
-
-  // Create backup directory
-  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const defaultBackupDir = join(
-    process.cwd(),
-    ".letta",
-    "backups",
-    agentId,
-    timestamp,
-  );
-  const backupPath = backupDir || defaultBackupDir;
-
-  mkdirSync(backupPath, { recursive: true });
-
-  console.log(`Backing up memory blocks for agent ${agentId}...`);
-  console.log(`Backup location: ${backupPath}`);
-
-  // Get all memory blocks
-  const blocksResponse = await client.agents.blocks.list(agentId);
-  const blocks = Array.isArray(blocksResponse)
-    ? blocksResponse
-    : (blocksResponse as { items?: unknown[] }).items ||
-      (blocksResponse as { blocks?: unknown[] }).blocks ||
-      [];
-
-  console.log(`Found ${blocks.length} memory blocks`);
-
-  // Export each block to a file
-  const manifest: BackupManifest = {
-    agent_id: agentId,
-    timestamp: new Date().toISOString(),
-    backup_path: backupPath,
-    blocks: [],
-  };
-
-  for (const block of blocks as Array<{
-    id: string;
-    label?: string;
-    value?: string;
-    limit?: number;
-  }>) {
-    const label = block.label || `block-${block.id}`;
-    // For hierarchical labels like "A/B", create directory A/ with file B.md
-    const filename = `${label}.md`;
-    const filepath = join(backupPath, filename);
-
-    // Create parent directories if label contains slashes
-    const parentDir = dirname(filepath);
-    if (parentDir !== backupPath) {
-      mkdirSync(parentDir, { recursive: true });
-    }
-
-    // Write block content to file
-    const content = block.value || "";
-    writeFileSync(filepath, content, "utf-8");
-
-    console.log(`  ✓ ${label} -> ${filename} (${content.length} chars)`);
-
-    // Add to manifest
-    manifest.blocks.push({
-      id: block.id,
-      label,
-      filename,
-      limit: block.limit || 0,
-      value_length: content.length,
-    });
-  }
-
-  // Write manifest
-  const manifestPath = join(backupPath, "manifest.json");
-  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
-  console.log(`  ✓ manifest.json`);
-
-  console.log(`\n✅ Backup complete: ${backupPath}`);
-  return backupPath;
-}
-
-// CLI Entry Point - check if this file is being run directly
-const isMainModule = import.meta.url === `file://${process.argv[1]}`;
-if (isMainModule) {
-  const args = process.argv.slice(2);
-
-  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
-    console.log(`
-Usage: npx tsx backup-memory.ts <agent-id> [backup-dir]
-
-Arguments:
-  agent-id     Agent ID to backup (can use $LETTA_AGENT_ID)
-  backup-dir   Optional custom backup directory
-               Default: .letta/backups/<agent-id>/<timestamp>
-
-Examples:
-  npx tsx backup-memory.ts agent-abc123
-  npx tsx backup-memory.ts $LETTA_AGENT_ID
-  npx tsx backup-memory.ts agent-abc123 .letta/backups/working
-    `);
-    process.exit(0);
-  }
-
-  const agentId = args[0];
-  const backupDir = args[1];
-
-  if (!agentId) {
-    console.error("Error: agent-id is required");
-    process.exit(1);
-  }
-
-  backupMemory(agentId, backupDir)
-    .then((path) => {
-      // Output just the path for easy capture in scripts
-      console.log(path);
-    })
-    .catch((error) => {
-      console.error(
-        "Error backing up memory:",
-        error instanceof Error ? error.message : String(error),
-      );
-      process.exit(1);
-    });
-}
-
-export { backupMemory };