@letta-ai/letta-code 0.28.10 → 0.28.12

package/skills/modifying-the-harness/scripts/add_hook.py

@@ -1,223 +0,0 @@
-#!/usr/bin/env python3
-"""
-Add a hook to Letta Code settings.
-
-Examples:
-    # Command hook for Bash tool calls
-    python3 add_hook.py --event PreToolUse --matcher Bash \
-        --type command --command 'echo "$TOOL_INPUT" >> audit.log' \
-        --scope user
-
-    # Prompt hook for pre-edit safety check
-    python3 add_hook.py --event PreToolUse --matcher "Edit|Write" \
-        --type prompt --prompt 'Is this safe? Input: $ARGUMENTS' \
-        --model gpt-5.2 --scope project
-
-    # Simple event hook (no matcher needed)
-    python3 add_hook.py --event Stop \
-        --type command --command 'say done' \
-        --scope user
-"""
-
-import argparse
-import json
-import os
-import sys
-from pathlib import Path
-
-TOOL_EVENTS = {"PreToolUse", "PostToolUse", "PostToolUseFailure", "PermissionRequest"}
-SIMPLE_EVENTS = {
-    "UserPromptSubmit",
-    "Notification",
-    "Stop",
-    "SubagentStop",
-    "PreCompact",
-    "SessionStart",
-    "SessionEnd",
-}
-ALL_EVENTS = TOOL_EVENTS | SIMPLE_EVENTS
-
-PROMPT_SUPPORTED = {
-    "PreToolUse",
-    "PostToolUse",
-    "PostToolUseFailure",
-    "PermissionRequest",
-    "UserPromptSubmit",
-    "Stop",
-    "SubagentStop",
-}
-
-
-def get_settings_path(scope: str, working_directory: str) -> Path:
-    if scope == "user":
-        return Path.home() / ".letta" / "settings.json"
-    elif scope == "project":
-        return Path(working_directory) / ".letta" / "settings.json"
-    elif scope == "local":
-        return Path(working_directory) / ".letta" / "settings.local.json"
-    else:
-        raise ValueError(f"Unknown scope: {scope}")
-
-
-def load_settings(path: Path) -> dict:
-    if path.exists():
-        try:
-            with open(path) as f:
-                return json.load(f)
-        except json.JSONDecodeError:
-            print(f"Warning: Could not parse {path}, starting fresh", file=sys.stderr)
-            return {}
-    return {}
-
-
-def save_settings(path: Path, settings: dict) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w") as f:
-        json.dump(settings, f, indent=2)
-    print(f"Saved to {path}")
-
-
-def build_hook_config(args) -> dict:
-    """Build the individual hook config from args."""
-    hook: dict = {"type": args.type}
-
-    if args.type == "command":
-        if not args.command:
-            raise ValueError("--command is required for type=command")
-        hook["command"] = args.command
-    elif args.type == "prompt":
-        if not args.prompt:
-            raise ValueError("--prompt is required for type=prompt")
-        if args.event not in PROMPT_SUPPORTED:
-            raise ValueError(
-                f"Event {args.event!r} does not support prompt hooks. "
-                f"Supported: {sorted(PROMPT_SUPPORTED)}"
-            )
-        hook["prompt"] = args.prompt
-        if args.model:
-            hook["model"] = args.model
-
-    if args.timeout is not None:
-        hook["timeout"] = args.timeout
-
-    return hook
-
-
-def add_hook(settings: dict, args) -> None:
-    """Add a hook entry to the settings dict."""
-    if "hooks" not in settings:
-        settings["hooks"] = {}
-
-    hooks_config = settings["hooks"]
-    event = args.event
-
-    if event not in hooks_config:
-        hooks_config[event] = []
-
-    hook = build_hook_config(args)
-
-    if event in TOOL_EVENTS:
-        # Tool events: need a matcher
-        matcher = args.matcher or "*"
-        # Find existing matcher group or create new one
-        entry = next(
-            (e for e in hooks_config[event] if e.get("matcher") == matcher), None
-        )
-        if entry is None:
-            entry = {"matcher": matcher, "hooks": []}
-            hooks_config[event].append(entry)
-        entry["hooks"].append(hook)
-    else:
-        # Simple events: no matcher, just hooks
-        if hooks_config[event]:
-            # Append to existing group
-            hooks_config[event][0].setdefault("hooks", []).append(hook)
-        else:
-            hooks_config[event].append({"hooks": [hook]})
-
-
-def ensure_local_gitignored(working_directory: str) -> None:
-    gitignore_path = Path(working_directory) / ".gitignore"
-    pattern = ".letta/settings.local.json"
-    try:
-        content = gitignore_path.read_text() if gitignore_path.exists() else ""
-        if pattern not in content:
-            with open(gitignore_path, "a") as f:
-                if content and not content.endswith("\n"):
-                    f.write("\n")
-                f.write(f"{pattern}\n")
-            print(f"Added {pattern} to .gitignore")
-    except Exception as e:
-        print(f"Warning: Could not update .gitignore: {e}", file=sys.stderr)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Add a hook to Letta Code settings",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=__doc__,
-    )
-    parser.add_argument(
-        "--event",
-        required=True,
-        choices=sorted(ALL_EVENTS),
-        help="Hook event name",
-    )
-    parser.add_argument(
-        "--matcher",
-        help="Tool matcher pattern (for tool events). Examples: 'Bash', 'Edit|Write', '*'",
-    )
-    parser.add_argument(
-        "--type",
-        required=True,
-        choices=["command", "prompt"],
-        help="Hook type",
-    )
-    parser.add_argument("--command", help="Shell command (for type=command)")
-    parser.add_argument(
-        "--prompt",
-        help="LLM prompt text (for type=prompt). Use $ARGUMENTS for hook input JSON.",
-    )
-    parser.add_argument("--model", help="LLM model (for type=prompt)")
-    parser.add_argument(
-        "--timeout", type=int, help="Timeout in milliseconds (default: 60000/30000)"
-    )
-    parser.add_argument(
-        "--scope",
-        required=True,
-        choices=["user", "project", "local"],
-        help="Where to save the hook",
-    )
-    parser.add_argument(
-        "--cwd",
-        default=os.getcwd(),
-        help="Working directory for project/local scope (default: cwd)",
-    )
-
-    args = parser.parse_args()
-
-    # Validation
-    if args.event in TOOL_EVENTS and not args.matcher:
-        print(
-            f"Warning: {args.event} is a tool event; using matcher='*' (match all tools)",
-            file=sys.stderr,
-        )
-
-    settings_path = get_settings_path(args.scope, args.cwd)
-    settings = load_settings(settings_path)
-
-    try:
-        add_hook(settings, args)
-    except ValueError as e:
-        print(f"Error: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    save_settings(settings_path, settings)
-    print(f"Added {args.type} hook on {args.event}")
-
-    if args.scope == "local":
-        ensure_local_gitignored(args.cwd)
-
-
-if __name__ == "__main__":
-    main()

package/skills/modifying-the-harness/scripts/add_permission.py

@@ -1,136 +0,0 @@
-#!/usr/bin/env python3
-"""
-Add a permission rule to Letta Code settings.
-
-Usage:
-    python3 add_permission.py --rule "Bash(npm run:*)" --type allow --scope user
-    python3 add_permission.py --rule "Read(src/**)" --type allow --scope project
-    python3 add_permission.py --rule "Bash(git push:*)" --type alwaysAsk --scope user
-"""
-
-import argparse
-import json
-import os
-import sys
-from pathlib import Path
-
-
-def get_settings_path(scope: str, working_directory: str) -> Path:
-    """Get the settings file path for a given scope."""
-    if scope == "user":
-        return Path.home() / ".letta" / "settings.json"
-    elif scope == "project":
-        return Path(working_directory) / ".letta" / "settings.json"
-    elif scope == "local":
-        return Path(working_directory) / ".letta" / "settings.local.json"
-    else:
-        raise ValueError(f"Unknown scope: {scope}")
-
-
-def load_settings(path: Path) -> dict:
-    """Load settings from a JSON file, or return empty dict if not found."""
-    if path.exists():
-        try:
-            with open(path) as f:
-                return json.load(f)
-        except json.JSONDecodeError:
-            print(f"Warning: Could not parse {path}, starting fresh", file=sys.stderr)
-            return {}
-    return {}
-
-
-def save_settings(path: Path, settings: dict) -> None:
-    """Save settings to a JSON file, creating parent directories if needed."""
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w") as f:
-        json.dump(settings, f, indent=2)
-    print(f"Saved to {path}")
-
-
-def add_rule(settings: dict, rule: str, rule_type: str) -> bool:
-    """
-    Add a permission rule to settings.
-
-    Returns True if the rule was added, False if it already exists.
-    """
-    if "permissions" not in settings:
-        settings["permissions"] = {}
-
-    if rule_type not in settings["permissions"]:
-        settings["permissions"][rule_type] = []
-
-    rules = settings["permissions"][rule_type]
-
-    if rule in rules:
-        return False
-
-    rules.append(rule)
-    return True
-
-
-def ensure_local_gitignored(working_directory: str) -> None:
-    """Ensure .letta/settings.local.json is in .gitignore."""
-    gitignore_path = Path(working_directory) / ".gitignore"
-    pattern = ".letta/settings.local.json"
-
-    try:
-        content = ""
-        if gitignore_path.exists():
-            content = gitignore_path.read_text()
-
-        if pattern not in content:
-            with open(gitignore_path, "a") as f:
-                if content and not content.endswith("\n"):
-                    f.write("\n")
-                f.write(f"{pattern}\n")
-            print(f"Added {pattern} to .gitignore")
-    except Exception as e:
-        print(f"Warning: Could not update .gitignore: {e}", file=sys.stderr)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Add a permission rule to Letta Code settings"
-    )
-    parser.add_argument(
-        "--rule",
-        required=True,
-        help='Permission rule pattern, e.g., "Bash(npm run:*)" or "Read(src/**)"',
-    )
-    parser.add_argument(
-        "--type",
-        required=True,
-        choices=["allow", "deny", "ask", "alwaysAsk"],
-        help="Type of permission rule",
-    )
-    parser.add_argument(
-        "--scope",
-        required=True,
-        choices=["user", "project", "local"],
-        help="Where to save the rule",
-    )
-    parser.add_argument(
-        "--cwd",
-        default=os.getcwd(),
-        help="Working directory for project/local scope (default: current directory)",
-    )
-
-    args = parser.parse_args()
-
-    settings_path = get_settings_path(args.scope, args.cwd)
-    settings = load_settings(settings_path)
-
-    if add_rule(settings, args.rule, args.type):
-        save_settings(settings_path, settings)
-        print(f"Added {args.type} rule: {args.rule}")
-
-        # Ensure local settings are gitignored
-        if args.scope == "local":
-            ensure_local_gitignored(args.cwd)
-    else:
-        print(f"Rule already exists: {args.rule}")
-        sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/skills/modifying-the-harness/scripts/show_config.py

@@ -1,212 +0,0 @@
-#!/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."""
-    rule_types = ["allow", "deny", "ask", "alwaysAsk"]
-    rules: dict[str, list[tuple[str, str]]] = {rule_type: [] for rule_type in rule_types}
-    for scope, settings in all_settings:
-        perms = settings.get("permissions", {})
-        for rule_type in rule_types:
-            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 rule_types:
-            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()