echo/build.py

#!/usr/bin/env python3
"""build.py — package the echo-memory plugin source into a .plugin artifact.

Zips the CONTENTS of echo-memory.plugin.src/ at the archive root (the layout the plugin
loader expects: .claude-plugin/plugin.json, commands/, skills/ all at top level), excluding
dev cruft. The version is read from the manifest, so the output is named automatically.

Usage:
  python build.py                # build echo-memory-<version>.plugin + refresh echo-memory.plugin
  python build.py --strip-key    # ALSO blank echo.py's DEFAULT_KEY -> a token-free artifact
                                  #   (requires ECHO_KEY or ~/.echo-memory/credentials at runtime)
  python build.py --no-pointer   # don't update the echo-memory.plugin "current" pointer
  python build.py --outdir dist  # write artifacts somewhere other than the repo root

Deterministic: entries are sorted and stamped with a fixed timestamp, so an unchanged
source tree always produces a byte-identical archive (clean diffs / reproducible builds).
Pure stdlib; runs the same on Windows/macOS/Linux.
"""
from __future__ import annotations

import argparse
import json
import re
import sys
import zipfile
from pathlib import Path

# Keep non-ASCII (em-dashes in our messages) from raising/garbling on a legacy console.
for _stream in (sys.stdout, sys.stderr):
    try:
        _stream.reconfigure(encoding="utf-8", errors="replace")  # type: ignore[union-attr]
    except Exception:
        pass

REPO = Path(__file__).resolve().parent
SRC = REPO / "echo-memory.plugin.src"
MANIFEST = "/".join([".claude-plugin", "plugin.json"])
ECHO_PY = "/".join(["skills", "echo-memory", "scripts", "echo.py"])

EXCLUDE_DIRS = {"__pycache__", ".git"}
EXCLUDE_NAMES = {".DS_Store"}
EXCLUDE_SUFFIXES = {".pyc", ".pyo"}
FIXED_DATE = (2026, 1, 1, 0, 0, 0)  # stable timestamp for reproducible archives

_KEY_RE = re.compile(r'(DEFAULT_KEY\s*=\s*")([0-9a-fA-F]{16,})(")')


def included_files() -> list[Path]:
    out = []
    for p in sorted(SRC.rglob("*")):
        if p.is_dir():
            continue
        if any(part in EXCLUDE_DIRS for part in p.relative_to(SRC).parts):
            continue
        if p.name in EXCLUDE_NAMES or p.suffix in EXCLUDE_SUFFIXES:
            continue
        out.append(p)
    return out


def file_bytes(path: Path, arcname: str, strip_key: bool) -> bytes:
    data = path.read_bytes()
    if strip_key and arcname == ECHO_PY:
        text = data.decode("utf-8")
        new, n = _KEY_RE.subn(r'\1\3', text)  # collapse the hex value to ""
        if n:
            text = new.replace('DEFAULT_KEY = ""',
                               'DEFAULT_KEY = ""  # stripped at build time — set ECHO_KEY or run write-key')
            data = text.encode("utf-8")
    return data


def token_present(path: Path) -> bool:
    m = _KEY_RE.search(path.read_text(encoding="utf-8"))
    return bool(m and m.group(2))


def build(out: Path, files: list[Path], strip_key: bool) -> int:
    if out.exists():
        out.unlink()
    with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as z:
        for p in files:
            arc = p.relative_to(SRC).as_posix()
            info = zipfile.ZipInfo(arc, date_time=FIXED_DATE)
            info.compress_type = zipfile.ZIP_DEFLATED
            info.external_attr = 0o644 << 16
            z.writestr(info, file_bytes(p, arc, strip_key))
    return out.stat().st_size


def main(argv: list[str] | None = None) -> int:
    ap = argparse.ArgumentParser(description="Build the echo-memory .plugin artifact")
    ap.add_argument("--strip-key", action="store_true",
                    help="blank echo.py DEFAULT_KEY so no token ships in the artifact")
    ap.add_argument("--no-pointer", action="store_true",
                    help="do not refresh the echo-memory.plugin 'current' pointer")
    ap.add_argument("--outdir", default=str(REPO), help="output directory (default: repo root)")
    args = ap.parse_args(argv)

    if not SRC.is_dir():
        print(f"build: source tree not found at {SRC}", file=sys.stderr)
        return 1

    manifest_path = SRC / ".claude-plugin" / "plugin.json"
    version = json.loads(manifest_path.read_text(encoding="utf-8"))["version"]
    files = included_files()
    arcnames = {p.relative_to(SRC).as_posix() for p in files}
    if MANIFEST not in arcnames:
        print(f"build: {MANIFEST} missing from the archive root — aborting", file=sys.stderr)
        return 1

    outdir = Path(args.outdir)
    outdir.mkdir(parents=True, exist_ok=True)
    targets = [outdir / f"echo-memory-{version}.plugin"]
    if not args.no_pointer:
        targets.append(outdir / "echo-memory.plugin")

    for out in targets:
        size = build(out, files, args.strip_key)
        print(f"built {out.name}  ({len(files)} entries, {size:,} bytes)")

    echo_src = SRC / "skills" / "echo-memory" / "scripts" / "echo.py"
    if args.strip_key:
        print("note: --strip-key set — artifact is token-free; runtime needs ECHO_KEY or a credentials file.")
    elif token_present(echo_src):
        print("WARNING: the baked-in DEFAULT_KEY is present in this artifact — do not share it. "
              "Set ECHO_KEY everywhere (API-KEY-SETUP.md), then build with --strip-key.")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())