@letta-ai/letta-code 0.23.11 → 0.24.0

package/skills/modifying-letta-code/scripts/show_config.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+Show the merged Letta Code harness configuration.
+
+Displays permissions, hooks, and per-agent settings across user/project/local
+scopes with their source scope annotated.
+
+Usage:
+    python3 show_config.py
+    python3 show_config.py --cwd /path/to/project
+    python3 show_config.py --json
+"""
+
+import argparse
+import json
+import os
+from pathlib import Path
+
+
+def get_settings_paths(working_directory: str) -> list[tuple[str, Path]]:
+    """Return (scope, path) in precedence order (lowest to highest)."""
+    return [
+        ("user", Path.home() / ".letta" / "settings.json"),
+        ("project", Path(working_directory) / ".letta" / "settings.json"),
+        ("local", Path(working_directory) / ".letta" / "settings.local.json"),
+    ]
+
+
+def load_settings(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return {}
+
+
+def format_permissions(
+    all_settings: list[tuple[str, dict]], as_json: bool
+) -> dict | None:
+    """Collect permissions from all scopes with sources."""
+    rules: dict[str, list[tuple[str, str]]] = {"allow": [], "deny": [], "ask": []}
+    for scope, settings in all_settings:
+        perms = settings.get("permissions", {})
+        for rule_type in ["allow", "deny", "ask"]:
+            for rule in perms.get(rule_type, []):
+                rules[rule_type].append((rule, scope))
+
+    if as_json:
+        return {
+            t: [{"rule": r, "scope": s} for r, s in rules[t]] for t in rules if rules[t]
+        }
+
+    total = sum(len(v) for v in rules.values())
+    print("=" * 60)
+    print(f"PERMISSIONS ({total} rules)")
+    print("=" * 60)
+    if total == 0:
+        print("  (none)")
+    else:
+        for rule_type in ["allow", "deny", "ask"]:
+            if rules[rule_type]:
+                print(f"\n  {rule_type.upper()}:")
+                for rule, scope in rules[rule_type]:
+                    print(f"    [{scope:7}] {rule}")
+    print()
+    return None
+
+
+def format_hooks(all_settings: list[tuple[str, dict]], as_json: bool) -> dict | None:
+    """Collect hooks from all scopes with sources."""
+    collected: dict[str, list[tuple[str, dict]]] = {}
+    for scope, settings in all_settings:
+        hooks = settings.get("hooks", {})
+        if not isinstance(hooks, dict):
+            continue
+        for event, entries in hooks.items():
+            if event == "disabled":
+                continue
+            if not isinstance(entries, list):
+                continue
+            collected.setdefault(event, []).extend((scope, e) for e in entries)
+
+    if as_json:
+        return {
+            event: [
+                {"scope": scope, **entry}
+                for scope, entry in entries
+            ]
+            for event, entries in collected.items()
+        }
+
+    total_groups = sum(len(v) for v in collected.values())
+    print("=" * 60)
+    print(f"HOOKS ({len(collected)} events, {total_groups} groups)")
+    print("=" * 60)
+    if not collected:
+        print("  (none)")
+    else:
+        for event, entries in sorted(collected.items()):
+            print(f"\n  {event}:")
+            for scope, entry in entries:
+                matcher = entry.get("matcher", "(no matcher)")
+                hook_list = entry.get("hooks", [])
+                for h in hook_list:
+                    htype = h.get("type", "?")
+                    detail = h.get("command") or h.get("prompt", "")
+                    detail = (
+                        (detail[:60] + "...") if len(detail) > 60 else detail
+                    )
+                    print(f"    [{scope:7}] matcher={matcher:15} {htype}: {detail}")
+    print()
+    return None
+
+
+def format_agents(all_settings: list[tuple[str, dict]], as_json: bool) -> dict | None:
+    """Collect per-agent settings (only from user settings.json)."""
+    agents = []
+    for scope, settings in all_settings:
+        for a in settings.get("agents", []):
+            agents.append({"scope": scope, **a})
+
+    if as_json:
+        return agents
+
+    print("=" * 60)
+    print(f"PER-AGENT SETTINGS ({len(agents)} entries)")
+    print("=" * 60)
+    if not agents:
+        print("  (none)")
+    else:
+        for a in agents:
+            scope = a.get("scope", "?")
+            aid = a.get("agentId", "?")
+            print(f"\n  [{scope:7}] {aid}")
+            for k in ("pinned", "memfs", "toolset", "systemPromptPreset", "baseUrl"):
+                if k in a:
+                    val = a[k]
+                    if isinstance(val, dict):
+                        val = json.dumps(val)
+                    print(f"    {k}: {val}")
+    print()
+    return None
+
+
+def format_settings_files(working_directory: str) -> None:
+    print("=" * 60)
+    print("SETTINGS FILES")
+    print("=" * 60)
+    for scope, path in get_settings_paths(working_directory):
+        exists = "✓" if path.exists() else "✗"
+        print(f"  {exists} [{scope:7}] {path}")
+    print()
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Show Letta Code harness configuration (permissions, hooks, agents)"
+    )
+    parser.add_argument(
+        "--cwd",
+        default=os.getcwd(),
+        help="Working directory for project/local scope (default: cwd)",
+    )
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    parser.add_argument(
+        "--section",
+        choices=["permissions", "hooks", "agents", "all"],
+        default="all",
+        help="Which section to show (default: all)",
+    )
+
+    args = parser.parse_args()
+
+    all_settings = [
+        (scope, load_settings(path))
+        for scope, path in get_settings_paths(args.cwd)
+    ]
+
+    if args.json:
+        output: dict = {}
+        if args.section in ("permissions", "all"):
+            perms = format_permissions(all_settings, as_json=True)
+            if perms:
+                output["permissions"] = perms
+        if args.section in ("hooks", "all"):
+            hooks = format_hooks(all_settings, as_json=True)
+            if hooks:
+                output["hooks"] = hooks
+        if args.section in ("agents", "all"):
+            agents = format_agents(all_settings, as_json=True)
+            if agents:
+                output["agents"] = agents
+        print(json.dumps(output, indent=2))
+    else:
+        print(f"\nLetta Code Harness Configuration")
+        print(f"Working directory: {args.cwd}\n")
+        if args.section == "all":
+            format_settings_files(args.cwd)
+        if args.section in ("permissions", "all"):
+            format_permissions(all_settings, as_json=False)
+        if args.section in ("hooks", "all"):
+            format_hooks(all_settings, as_json=False)
+        if args.section in ("agents", "all"):
+            format_agents(all_settings, as_json=False)
+        print("Precedence (highest to lowest): local > project > user\n")
+
+
+if __name__ == "__main__":
+    main()

package/skills/syncing-memory-filesystem/SKILL.md

@@ -21,8 +21,10 @@ When memfs is enabled, the Letta Code CLI automatically:
 2. Clones the repo into `~/.letta/agents/<agent-id>/memory/` (git root is the memory directory)
 3. Configures a **local** credential helper in `memory/.git/config` (so `git push`/`git pull` work without auth ceremony)
 4. Installs a **pre-commit hook** that validates frontmatter before each commit (see below)
-5. On subsequent startups: pulls latest changes, reconfigures credentials and hook (self-healing)
-6. During sessions: periodically checks `git status` and reminds you (the agent) to commit/push if dirty
+5. Installs a **post-commit hook** that pushes commits to an optional additional remote (see "Additional memory-repository remote" below)
+6. Sets canonical local git identity (`letta.agentId`, `user.name`, `user.email`) so direct `git commit` from the agent's shell attributes correctly to the agent — not the operator's global git identity
+7. On subsequent startups: pulls latest changes, reconfigures credentials, hooks, and identity (self-healing)
+8. During sessions: periodically checks `git status` and reminds you (the agent) to commit/push if dirty
 
 If any of these steps fail, you can replicate them manually using the sections below.
 
@@ -83,6 +85,33 @@ Block content goes here.
 
 If the hook rejects a commit, read the error message — it tells you exactly which file and which rule was violated. Fix the file and retry.
 
+## Additional Memory-Repository Remote
+
+In addition to pushing to the Letta server, you can push every commit to a second git remote — e.g. a private GitHub repo — so you have a backup or a copy you can browse with regular tools.
+
+**Via the slash command (recommended):**
+```
+/memory-repository set git@github.com:you/my-memory.git
+/memory-repository status
+/memory-repository push        # force a push now, e.g. after a network failure
+/memory-repository unset       # stop pushing
+```
+
+**How it works:**
+- `/memory-repository set <url>` writes the URL to `letta.memoryRepository.url` in the memfs repo's local `.git/config` and installs a `post-commit` hook.
+- After every commit, the hook reads `letta.memoryRepository.url` and asynchronously pushes to it in the background. Commits are never blocked by push failures.
+- Push output and exit codes are appended to `.git/memory-repository-push.log` — visible via `/memory-repository status`.
+- The setting is **per-repo**, so each agent on a machine has its own independent configuration.
+
+**Auth:** uses your existing git credentials — SSH keys, credential helpers, or tokens in the URL. Letta does not store tokens for this feature. If you're pushing to GitHub, SSH is easiest.
+
+**Manual equivalent (without the slash command):**
+```bash
+cd ~/.letta/agents/<agent-id>/memory
+git config --local letta.memoryRepository.url git@github.com:you/my-memory.git
+# Hook is installed automatically by the CLI on startup; no manual install needed.
+```
+
 ## Clone Agent Memory
 
 ```bash