savant-code 0.0.19 → 0.0.21

package/scripts/sync-agents.py

@@ -1,337 +0,0 @@
-#!/usr/bin/env python3
-"""
-savant-protocol/scripts/sync-agents.py
-
-Push ECHO Protocol to one or more agent homes.
-
-USAGE
-    python sync-agents.py                    # dry-run; shows what would be pushed
-    python sync-agents.py --apply            # actually copy files
-    python sync-agents.py --target <name>    # only push to one named target
-    python sync-agents.py --list             # show available targets
-    python sync-agents.py --init             # generate a default sync.yaml
-
-WHAT IT COPIES
-    For each target, copies a configured set of files from this
-    savant-protocol/ source to the target's destination.
-
-    Targets with mode "copy"  -> source file copied as-is to dest
-    Targets with mode "strip" -> source file copied with the trailing
-                                "Project: <name>" section removed
-                                (used for project-tail-amended ECHO.md)
-
-DEFAULTS (edit sync.yaml to customize)
-    - NOVA   (Hermes agent at ~/.hermes/)   -> universal core, no project tail
-    - MYA    (OpenClaw agent at ~/.openclaw/) -> universal core, no project tail
-    - SAVANT-TRADING (savant-trading repo)   -> full file with project tail kept
-"""
-
-import argparse
-import shutil
-import sys
-from dataclasses import dataclass, field
-from pathlib import Path
-
-PROTOCOL_ROOT = Path(__file__).resolve().parent.parent
-DEFAULT_SYNC_FILE = PROTOCOL_ROOT / "scripts" / "sync.yaml"
-
-
-@dataclass
-class Target:
-    """One destination the protocol gets pushed to."""
-
-    name: str
-    root: Path
-    mode: str = "copy"  # "copy" = file as-is, "strip-project-tail" = trim trailing project section
-    files: list = field(default_factory=list)
-
-    def resolve_dest(self, rel_path: Path) -> Path:
-        return self.root / rel_path
-
-
-@dataclass
-class SyncPlan:
-    """The full push plan: one or more targets, each with a list of relative source files."""
-
-    source: Path
-    targets: list
-
-    def expand_files(self, rel_paths: list) -> list:
-        return [self.source / p for p in rel_paths]
-
-
-DEFAULT_TARGETS = [
-    Target(
-        name="NOVA",
-        root=Path.home() / "AppData" / "Local" / "hermes",
-        mode="copy",
-        files=[
-            "ECHO.md",
-            "STARTER-PROMPT.md",
-            "MIGRATION.md",
-            "protocol.config.yaml",
-            "coding-standards/csharp.md",
-            "coding-standards/go.md",
-            "coding-standards/java.md",
-            "coding-standards/python.md",
-            "coding-standards/rust.md",
-            "coding-standards/typescript.md",
-            "coding-standards/release-workflow.md",
-            "coding-standards/x402.md",
-            "templates/FID-TEMPLATE.md",
-            "templates/SESSION-SUMMARY.md",
-        ],
-    ),
-    Target(
-        name="MYA",
-        root=Path.home() / ".openclaw",
-        mode="copy",
-        files=[
-            "ECHO.md",
-            "STARTER-PROMPT.md",
-            "MIGRATION.md",
-            "protocol.config.yaml",
-            "coding-standards/csharp.md",
-            "coding-standards/go.md",
-            "coding-standards/java.md",
-            "coding-standards/python.md",
-            "coding-standards/rust.md",
-            "coding-standards/typescript.md",
-            "coding-standards/release-workflow.md",
-            "coding-standards/x402.md",
-            "templates/FID-TEMPLATE.md",
-            "templates/SESSION-SUMMARY.md",
-        ],
-    ),
-    Target(
-        name="SAVANT-TRADING",
-        root=PROTOCOL_ROOT.parent / "savant-trading",
-        mode="copy",
-        files=[
-            "ECHO.md",
-            "STARTER-PROMPT.md",
-            "MIGRATION.md",
-            "coding-standards/csharp.md",
-            "coding-standards/go.md",
-            "coding-standards/java.md",
-            "coding-standards/python.md",
-            "coding-standards/rust.md",
-            "coding-standards/typescript.md",
-            "coding-standards/release-workflow.md",
-            "templates/FID-TEMPLATE.md",
-            "templates/SESSION-SUMMARY.md",
-        ],
-    ),
-]
-
-
-def strip_project_tail(content: str) -> str:
-    """Remove the trailing '## Project: ...' section from an ECHO.md file.
-
-    The universal core ends with '---' before any project-specific section.
-    This finds the LAST '## Project:' line and trims from there.
-    """
-    marker = "\n## Project:"
-    idx = content.rfind(marker)
-    if idx == -1:
-        return content
-    cutoff = content.rfind("\n---\n", 0, idx)
-    if cutoff == -1:
-        return content
-    return content[: cutoff + 5].rstrip() + "\n"
-
-
-def plan_push(target: Target, source: Path) -> list:
-    """Return a list of (src_path, dest_path, action) tuples."""
-    actions = []
-    for rel in target.files:
-        src = source / rel
-        if not src.exists():
-            actions.append((src, None, "MISSING-SOURCE"))
-            continue
-        dest = target.resolve_dest(Path(rel))
-        if target.mode == "strip-project-tail" and src.name == "ECHO.md":
-            actions.append((src, dest, "strip"))
-        else:
-            actions.append((src, dest, "copy"))
-    return actions
-
-
-def execute_push(actions: list, apply: bool) -> list:
-    """Execute the push plan; return list of (action, src, dest, status) results."""
-    results = []
-    for src, dest, action in actions:
-        if action == "MISSING-SOURCE":
-            results.append((action, src, None, "skipped"))
-            continue
-        if not apply:
-            results.append((action, src, dest, "dry-run"))
-            continue
-        dest.parent.mkdir(parents=True, exist_ok=True)
-        if action == "strip":
-            content = src.read_text(encoding="utf-8")
-            stripped = strip_project_tail(content)
-            dest.write_text(stripped, encoding="utf-8")
-            results.append((action, src, dest, f"wrote {len(stripped)} bytes (stripped tail)"))
-        else:
-            shutil.copy2(src, dest)
-            results.append((action, src, dest, f"copied {src.stat().st_size} bytes"))
-    return results
-
-
-def load_sync_file(path: Path) -> list:
-    """Load custom target list from sync.yaml.
-
-    Format (intentionally simple — no PyYAML dep):
-        target:
-          - name: NOVA
-            root: C:/Users/...
-            mode: copy
-            files:
-              - ECHO.md
-              - coding-standards/rust.md
-    """
-    if not path.exists():
-        return DEFAULT_TARGETS
-    text = path.read_text(encoding="utf-8")
-    targets = []
-    current = None
-    in_files = False
-    for line in text.splitlines():
-        stripped = line.strip()
-        if not stripped or stripped.startswith("#"):
-            continue
-        if stripped == "target:":
-            if current is not None:
-                targets.append(current)
-            current = {"files": []}
-            in_files = False
-            continue
-        if current is None:
-            continue
-        if stripped.startswith("- "):
-            kv = stripped[2:]
-            if ":" in kv and not in_files:
-                key, _, val = kv.partition(":")
-                current[key.strip()] = val.strip()
-                in_files = False
-        elif stripped.startswith("files:"):
-            in_files = True
-        elif in_files and stripped.startswith("- "):
-            current["files"].append(stripped[2:].strip())
-    if current is not None:
-        targets.append(current)
-    parsed = []
-    for t in targets:
-        parsed.append(
-            Target(
-                name=t.get("name", "?"),
-                root=Path(t["root"]),
-                mode=t.get("mode", "copy"),
-                files=t.get("files", []),
-            )
-        )
-    return parsed
-
-
-def write_default_sync_file(path: Path) -> None:
-    """Generate a default sync.yaml the user can edit."""
-    content = """# savant-protocol sync targets
-# Edit paths/files, then run: python sync-agents.py --apply
-
-target:
-  - name: NOVA
-    root: C:/Users/<you>/AppData/Local/hermes
-    mode: copy
-    files:
-      - ECHO.md
-      - STARTER-PROMPT.md
-      - MIGRATION.md
-      - protocol.config.yaml
-      - coding-standards/rust.md
-      - coding-standards/python.md
-      - coding-standards/typescript.md
-      - coding-standards/x402.md
-      - templates/FID-TEMPLATE.md
-      - templates/SESSION-SUMMARY.md
-
-  - name: MYA
-    root: C:/Users/<you>/.openclaw
-    mode: copy
-    files:
-      - ECHO.md
-      - STARTER-PROMPT.md
-      - MIGRATION.md
-      - protocol.config.yaml
-      - coding-standards/rust.md
-      - coding-standards/python.md
-      - coding-standards/typescript.md
-      - coding-standards/x402.md
-      - templates/FID-TEMPLATE.md
-      - templates/SESSION-SUMMARY.md
-"""
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(content, encoding="utf-8")
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-    ap.add_argument("--apply", action="store_true", help="Actually copy files (default: dry-run)")
-    ap.add_argument("--target", help="Only push to one named target")
-    ap.add_argument("--list", action="store_true", help="List configured targets")
-    ap.add_argument("--init", action="store_true", help="Write a default sync.yaml")
-    ap.add_argument("--sync-file", default=str(DEFAULT_SYNC_FILE), help="Path to sync.yaml")
-    args = ap.parse_args()
-
-    if args.init:
-        write_default_sync_file(Path(args.sync_file))
-        print(f"Wrote default {args.sync_file}")
-        return 0
-
-    targets = load_sync_file(Path(args.sync_file))
-    if args.list:
-        print(f"Configured targets ({len(targets)}):")
-        for t in targets:
-            print(f"  {t.name:20s} {t.root}  [{t.mode}]  {len(t.files)} files")
-        return 0
-
-    if args.target:
-        targets = [t for t in targets if t.name.lower() == args.target.lower()]
-        if not targets:
-            print(f"No target named '{args.target}'", file=sys.stderr)
-            return 1
-
-    apply = args.apply
-    print(f"Source: {PROTOCOL_ROOT}")
-    print(f"Mode:   {'APPLY' if apply else 'DRY-RUN'}")
-    print()
-
-    grand_total = 0
-    for target in targets:
-        if not target.root.exists():
-            print(f"[{target.name}] SKIP — target root does not exist: {target.root}")
-            print()
-            continue
-        print(f"[{target.name}] -> {target.root}")
-        actions = plan_push(target, PROTOCOL_ROOT)
-        results = execute_push(actions, apply)
-        for action, src, dest, status in results:
-            if action == "MISSING-SOURCE":
-                print(f"  MISSING  {src}")
-            elif dest is None:
-                continue
-            elif action == "copy":
-                verb = "WOULD COPY" if not apply else "COPIED   "
-                print(f"  {verb} {src.name}  ->  {dest}")
-            elif action == "strip":
-                verb = "WOULD STRIP" if not apply else "STRIPPED  "
-                print(f"  {verb}  {src.name}  ->  {dest}  ({status})")
-        grand_total += len(results)
-        print()
-
-    print(f"Total: {grand_total} file(s) {'pushed' if apply else 'would push'}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/scripts/tmux/README.md

@@ -1,359 +0,0 @@
-<!-- markdownlint-disable MD041 -->
-<img src="../assets/banner.png" alt="tmux Test Scripts — Interact with TUIs reliably via bracketed paste" width="650" />
-
-# tmux TUI Testing Scripts
-
-Helper scripts for testing TUI applications (Terminal User Interface apps) using tmux. These scripts abstract away
-the complexity of tmux communication, particularly the **bracketed paste mode** requirement.
-
-For the CLI / SDK / repo Quick Start, see the [root README](../../README.md).
-
-## Features
-
-- **Automatic bracketed paste mode** - Input is wrapped in escape sequences so characters don't get dropped
-- **Automatic session logs** - Every capture is saved to `debug/tmux-sessions/{session}/` for debugging
-- **Works with any TUI app** - SavantCode, Claude Code, Codex, or any custom TUI application
-- **Paper trail** - Both the subagent and parent agent can review what the app displayed
-
-## Why These Scripts?
-
-Many TUI apps (using frameworks like OpenTUI, Ink, Textual, etc.) process keyboard input character-by-character.
-When tmux sends characters rapidly via `send-keys`, they get dropped or garbled. These scripts automatically wrap
-input in bracketed paste escape sequences (`\e[200~...\e[201~`), which tells the terminal to process the input
-atomically.
-
-**Without these scripts:**
-```bash
-# ❌ Characters get dropped!
-tmux send-keys -t session "hello world"
-# Result: Only "d" appears in the input!
-```
-
-**With these scripts:**
-```bash
-# ✅ Works correctly
-./scripts/tmux/tmux-send.sh session "hello world"
-# Result: "hello world" appears correctly
-```
-
-## Quick Start
-
-### Testing Any TUI App
-
-```bash
-# Start a test session with any command
-SESSION=$(./scripts/tmux/tmux-cli.sh start --command "claude")
-SESSION=$(./scripts/tmux/tmux-cli.sh start --command "codex chat")
-SESSION=$(./scripts/tmux/tmux-cli.sh start --command "python my_tui.py")
-echo "Started session: $SESSION"
-
-# Send a command
-./scripts/tmux/tmux-cli.sh send "$SESSION" "/help"
-
-# Wait and capture output
-./scripts/tmux/tmux-cli.sh capture "$SESSION" --wait 2
-
-# Clean up
-./scripts/tmux/tmux-cli.sh stop "$SESSION"
-```
-
-### Testing SavantCode (Default)
-
-```bash
-# Start a test session (defaults to SavantCode dev server)
-SESSION=$(./scripts/tmux/tmux-cli.sh start)
-echo "Started session: $SESSION"
-
-# Send a command
-./scripts/tmux/tmux-cli.sh send "$SESSION" "/help"
-
-# Wait and capture output
-./scripts/tmux/tmux-cli.sh capture "$SESSION" --wait 2
-
-# Clean up
-./scripts/tmux/tmux-cli.sh stop "$SESSION"
-```
-
-### Testing Compiled Binaries
-
-```bash
-# Build the binary first (SavantCode example)
-cd cli && bun run build:binary
-
-# Test with binary at default location (./cli/bin/savant-code)
-SESSION=$(./scripts/tmux/tmux-cli.sh start --binary)
-
-# Or specify a custom binary path
-SESSION=$(./scripts/tmux/tmux-cli.sh start --binary /path/to/binary)
-
-# Or use environment variable
-CODEBUFF_BINARY=./cli/bin/savant-code ./scripts/tmux/tmux-cli.sh start
-```
-
-The session-info.yaml will record which mode was used (`cli_mode: custom`, `cli_mode: binary`, or `cli_mode: dynamic`).
-
-## Scripts
-
-### `tmux-cli.sh` (Unified Interface)
-
-The main entry point with subcommands:
-
-```bash
-./scripts/tmux/tmux-cli.sh start      # Start a session
-./scripts/tmux/tmux-cli.sh send       # Send input
-./scripts/tmux/tmux-cli.sh capture    # Capture output
-./scripts/tmux/tmux-cli.sh stop       # Stop a session
-./scripts/tmux/tmux-cli.sh list       # List sessions
-./scripts/tmux/tmux-cli.sh help       # Show help
-```
-
-### `tmux-start.sh`
-
-Start a new tmux session with a TUI app.
-
-```bash
-# Start with a custom command (any TUI app)
-./scripts/tmux/tmux-start.sh --command "claude"
-./scripts/tmux/tmux-start.sh --command "codex chat"
-./scripts/tmux/tmux-start.sh --command "python my_app.py"
-
-# Default settings (SavantCode dev server)
-./scripts/tmux/tmux-start.sh
-# Output: tui-test-1234567890
-
-# Custom session name
-./scripts/tmux/tmux-start.sh --name my-test
-
-# Custom dimensions
-./scripts/tmux/tmux-start.sh -w 160 -h 40
-
-# Custom wait time for app initialization
-./scripts/tmux/tmux-start.sh --wait 6
-
-# Test a compiled binary (default location: ./cli/bin/savant-code)
-./scripts/tmux/tmux-start.sh --binary
-
-# Test a compiled binary at custom path
-./scripts/tmux/tmux-start.sh --binary /path/to/binary
-```
-
-### `tmux-send.sh`
-
-Send input to a running session.
-
-```bash
-# Send text (auto-presses Enter)
-./scripts/tmux/tmux-send.sh SESSION "your prompt"
-
-# Send without pressing Enter
-./scripts/tmux/tmux-send.sh SESSION "partial" --no-enter
-
-# Send special keys
-./scripts/tmux/tmux-send.sh SESSION --key Escape
-./scripts/tmux/tmux-send.sh SESSION --key C-c
-./scripts/tmux/tmux-send.sh SESSION --key Enter
-
-# Send and wait for CLI to finish streaming (for rapid message tests)
-./scripts/tmux/tmux-send.sh SESSION "hello" --wait-idle 2
-
-# Paste clipboard content and submit immediately
-./scripts/tmux/tmux-send.sh SESSION --paste
-
-# Paste clipboard but don't submit (useful for testing attachment UI)
-# This lets you capture a screenshot of the attachment card before sending
-./scripts/tmux/tmux-send.sh SESSION --paste --no-enter
-```
-
-### `tmux-capture.sh`
-
-Capture output from a session. **Automatically saves captures** to `debug/tmux-sessions/{session}/`.
-
-```bash
-# Basic capture (auto-saves to session logs)
-./scripts/tmux/tmux-capture.sh SESSION
-
-# Capture with a descriptive label (recommended)
-./scripts/tmux/tmux-capture.sh SESSION --label "after-help-command"
-# Saves to: debug/tmux-sessions/SESSION/capture-{sequence}-after-help-command.txt
-
-# Wait before capturing
-./scripts/tmux/tmux-capture.sh SESSION --wait 3
-
-# Capture without auto-saving to session logs
-./scripts/tmux/tmux-capture.sh SESSION --no-save
-
-# Preserve colors
-./scripts/tmux/tmux-capture.sh SESSION --colors
-
-# Save to specific file (disables auto-save)
-./scripts/tmux/tmux-capture.sh SESSION -o output.txt
-```
-
-### `tmux-stop.sh`
-
-Stop/kill sessions.
-
-```bash
-# Stop specific session
-./scripts/tmux/tmux-stop.sh SESSION
-
-# Stop all test sessions (tui-test-* and cli-test-*)
-./scripts/tmux/tmux-stop.sh --all
-
-# List sessions first, then stop
-./scripts/tmux/tmux-stop.sh --list SESSION
-```
-
-## Example: Full Test Workflow
-
-```bash
-#!/bin/bash
-
-# Start session with a TUI app
-SESSION=$(./scripts/tmux/tmux-cli.sh start --command "my-tui-app" --name my-test)
-echo "Testing in: $SESSION"
-
-# Verify app started (capture auto-saved with label)
-./scripts/tmux/tmux-cli.sh capture "$SESSION" --label "initial-state"
-
-# Send /status command
-./scripts/tmux/tmux-cli.sh send "$SESSION" "/status"
-./scripts/tmux/tmux-cli.sh capture "$SESSION" --wait 2 --label "after-status"
-
-# Test a prompt
-./scripts/tmux/tmux-cli.sh send "$SESSION" "hello world"
-./scripts/tmux/tmux-cli.sh capture "$SESSION" --wait 5 --label "after-prompt"
-
-# Clean up
-./scripts/tmux/tmux-cli.sh stop "$SESSION"
-echo "Test complete!"
-
-# View all session logs
-ls -la debug/tmux-sessions/$SESSION/
-```
-
-## Session Logs Directory Structure
-
-```text
-debug/tmux-sessions/
-└── tui-test-1234567890/
-    ├── session-info.yaml             # Session metadata (YAML format)
-    ├── commands.yaml                 # Log of all commands sent (YAML array)
-    ├── capture-001-initial-state.txt # Captures with YAML front-matter
-    ├── capture-002-after-status.txt
-    └── capture-003-after-prompt.txt
-```
-
-### Session Info (session-info.yaml)
-
-```yaml
-session: tui-test-1234567890
-started: 2025-01-01T12:00:00Z
-started_local: Wed Jan  1 12:00:00 PST 2025
-dimensions:
-  width: 120
-  height: 30
-cli_mode: custom  # or "binary" or "dynamic"
-cli_command: claude  # or path to binary, or "cd cli && bun run dev"
-status: active
-```
-
-### Commands Log (commands.yaml)
-
-The `commands.yaml` file records every input sent to the app as a YAML array:
-
-```yaml
-- timestamp: 2025-01-01T12:00:05Z
-  type: text
-  input: "/help"
-  auto_enter: true
-
-- timestamp: 2025-01-01T12:00:10Z
-  type: text
-  input: "hello world"
-  auto_enter: true
-
-- timestamp: 2025-01-01T12:00:15Z
-  type: key
-  input: "Escape"
-
-- timestamp: 2025-01-01T12:00:20Z
-  type: text
-  input: "partial input"
-  auto_enter: false
-```
-
-### Capture Files with YAML Front-Matter
-
-Each capture file includes YAML front-matter with metadata:
-
-```yaml
----
-sequence: 1
-label: initial-state
-timestamp: 2025-01-01T12:00:30Z
-after_command: null
-dimensions:
-  width: 120
-  height: 30
----
-[actual terminal output below]
-```
-
-The front-matter provides:
-
-- **sequence**: Order of captures (1, 2, 3, ...)
-- **label**: Descriptive label if provided via `--label`
-- **timestamp**: ISO 8601 timestamp
-- **after_command**: The last command sent before this capture (or `null`)
-- **dimensions**: Terminal dimensions at capture time
-
-This structured format enables both human reading and programmatic parsing (AI agents, viewers, etc.).
-
-## Debugging
-
-### Attach to a Session Interactively
-
-```bash
-tmux attach -t SESSION_NAME
-# Detach with Ctrl+B, D
-```
-
-### List All Sessions
-
-```bash
-./scripts/tmux/tmux-cli.sh list
-# or
-tmux list-sessions
-```
-
-### Check If Session Exists
-
-```bash
-tmux has-session -t SESSION_NAME && echo "exists" || echo "not found"
-```
-
-## Prerequisites
-
-- **tmux** must be installed:
-  - macOS: `brew install tmux`
-  - Ubuntu: `sudo apt-get install tmux`
-  - Arch: `sudo pacman -S tmux`
-
-## Used By
-
-These scripts are used by TUI testing agents:
-
-- `@savant-code-tester` - Tests the SavantCode CLI
-- `@claude-code-tester` - Tests Claude Code CLI
-- `@codex-tester` - Tests OpenAI Codex CLI
-- `@gemini-tester` - Tests Google Gemini CLI
-- Custom agents for other TUI apps can easily be created following the same pattern
-
----
-
-## License
-
-[Apache-2.0](../../LICENSE) — see [LICENSE](../../LICENSE) for full text.
-
-<sub>Part of [savant-code/savant-code monorepo](https://github.com/savant0x/savant-code) — **Savant** • 2026</sub>

package/scripts/tmux/package.json

@@ -1,9 +0,0 @@
-{
-  "name": "@savant-code/tmux-scripts",
-  "version": "0.0.1",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "view-session": "bun run tmux-viewer/index.tsx"
-  }
-}