app-theme

#!/usr/bin/env python3
"""Make the tools Omarchy does not cover follow the theme.

  app-theme scan            JSON: which tools are installed and which follow
  app-theme on <tool>       start following the theme
  app-theme off <tool>      stop, leaving the file as it was
  app-theme reapply         rewrite every block that is on (the theme hook)

Omarchy already retints terminals, btop, helix, tmux, VS Code, Obsidian, the
browsers and more on every theme switch. These three it does not:

  bat     follows the terminal's own colours (--theme=ansi)
  delta   git's diff colours, from the theme's palette
  fzf     the picker's colours, from the theme's palette

Each lives between Lacquer's fences in the tool's own config, so what was
already there is untouched and switching off removes exactly what was added.
"""
import json, os, re, subprocess, sys, tempfile

HOME = os.environ.get("HOME", "")
STATE = os.path.join(HOME, ".local/state/omarchy/current/theme/colors.toml")
GEN_DIR = os.path.join(HOME, ".config/lacquer")
BEGIN = ">>> lacquer managed block >>>"
END = "<<< lacquer managed block <<<"
READ_LIMIT = 512 * 1024
HEX = re.compile(r"^#?([0-9a-fA-F]{6})$")


def read_capped(path):
    try:
        if not os.path.isfile(path) or os.path.getsize(path) > READ_LIMIT:
            return None
        with open(path, encoding="utf-8") as f:
            return f.read(READ_LIMIT + 1)[:READ_LIMIT]
    except (OSError, UnicodeDecodeError):
        return None


def read_or_refuse(path):
    """The file's text, "" when there is no file yet — never a silent empty.

    A file that exists but cannot be read here (too big, not UTF-8, not a
    regular file) must not be treated as an empty one: writing would replace
    somebody's config with nothing but Lacquer's block. Say so and stop.
    """
    if not os.path.lexists(path):
        return ""
    text = read_capped(path)
    if text is None:
        raise SystemExit(
            "%s cannot be read as text (too large, not UTF-8, or not a regular\n"
            "file), so Lacquer will not write to it. Nothing was changed."
            % path.replace(HOME, "~"))
    return text


def colors():
    """The theme's palette, as #rrggbb strings."""
    out = {}
    for line in (read_capped(STATE) or "").splitlines():
        m = re.match(r'^\s*([a-z0-9_]+)\s*=\s*"?(#?[0-9a-fA-F]{6})"?', line)
        if m:
            out.setdefault(m.group(1), "#" + HEX.match(m.group(2)).group(1).lower())
    out.setdefault("background", "#1e1e2e")
    out.setdefault("foreground", "#cdd6f4")
    out.setdefault("accent", out["foreground"])
    return out


def installed(command):
    return subprocess.run(["bash", "-lc", "command -v " + command + " >/dev/null"],
                          capture_output=True, timeout=10).returncode == 0


def write_text(path, text):
    # A file left holding nothing but whitespace is a file Lacquer created and
    # then emptied; take it away rather than leaving litter behind. A symlink
    # is never one Lacquer made — it is a dotfile manager's — so empty the file
    # it points at and leave the link where the manager put it.
    if text.strip() == "" and os.path.isfile(path) and not os.path.islink(path):
        os.remove(path)
        # And the folder it lived in, when nothing else is in it: switching a
        # tool on can create ~/.config/bat, and switching it off again should
        # not leave an empty one behind. Only a folder directly inside
        # ~/.config is considered, so a home folder is never a candidate, and
        # rmdir refuses anything that still has something in it.
        folder = os.path.dirname(path)
        if folder == GEN_DIR or os.path.dirname(folder) == os.path.join(HOME, ".config"):
            try:
                os.rmdir(folder)
            except OSError:
                pass
        return
    if text.strip() == "" and not os.path.islink(path):
        return
    # Write through a symlink, not over it: these configs are often links into
    # a dotfile repository, and replacing the link would quietly stop the
    # repository tracking the file.
    target = os.path.realpath(path)
    os.makedirs(os.path.dirname(target), exist_ok=True)
    fd, tmp = tempfile.mkstemp(prefix=".lacquer.", dir=os.path.dirname(target))
    try:
        with os.fdopen(fd, "w", encoding="utf-8") as f:
            f.write(text)
        if os.path.exists(target):
            os.chmod(tmp, os.stat(target).st_mode & 0o777)
        os.replace(tmp, target)
    except BaseException:
        try:
            os.unlink(tmp)
        except OSError:
            pass
        raise


def replace_block(text, body, comment="#"):
    """Put body between the fences, or take the block out when body is empty."""
    begin, end = comment + " " + BEGIN, comment + " " + END
    start = text.find(begin)
    if start < 0:
        if not body:
            return text
        head = text if text == "" or text.endswith("\n") else text + "\n"
        return head + ("\n" if head else "") + begin + "\n" + body + "\n" + end + "\n"
    stop = text.find(end, start)
    after = "" if stop < 0 else text[stop + len(end):].lstrip("\n")
    before = text[:start]
    if not body:
        return (before.rstrip("\n") + "\n" + after).lstrip("\n") if after else before.rstrip("\n") + "\n"
    return before + begin + "\n" + body + "\n" + end + "\n" + (after if after else "")


# ------------------------------------------------------------------- tools

def bat_body(c):
    return "--theme=ansi"


def delta_body(c):
    # Added lines take the theme's green and removed lines its red, darkened so
    # the text stays readable on top; a theme without either falls back to the
    # accent rather than colouring both the same.
    added = c.get("green", c.get("bright_green", c["accent"]))
    removed = c.get("red", c.get("urgent", c.get("bright_red", c["accent"])))
    return "\n".join([
        "[delta]",
        "    syntax-theme = ansi",
        "    plus-style = syntax \"%s\"" % shade(added, 0.5),
        "    minus-style = normal \"%s\"" % shade(removed, 0.5),
        "    line-numbers-zero-style = \"%s\"" % c["foreground"],
        "    file-style = \"%s\"" % c["accent"],
    ])


def fzf_body(c):
    opts = ",".join([
        "bg+:-1", "bg:-1",
        "fg:%s" % c["foreground"], "fg+:%s" % c["foreground"],
        "hl:%s" % c["accent"], "hl+:%s" % c["accent"],
        "info:%s" % c["accent"], "prompt:%s" % c["accent"],
        "pointer:%s" % c["accent"], "marker:%s" % c["accent"],
        "border:%s" % c["accent"], "header:%s" % c["foreground"],
    ])
    return 'export FZF_DEFAULT_OPTS="${FZF_DEFAULT_OPTS:+$FZF_DEFAULT_OPTS }--color=%s"' % opts


def shade(hex_color, factor):
    """Darken towards black, so a diff background stays readable."""
    m = HEX.match(hex_color)
    if not m:
        return hex_color
    value = int(m.group(1), 16)
    parts = [(value >> 16) & 255, (value >> 8) & 255, value & 255]
    return "#" + "".join("%02x" % max(0, min(255, int(p * factor))) for p in parts)


TOOLS = {
    "bat": {
        "name": "File viewer (bat)",
        "command": "bat",
        "path": os.path.join(HOME, ".config/bat/config"),
        "body": bat_body,
        "what": "Shows files in the terminal in colour. It will follow your theme.",
    },
    "delta": {
        "name": "Code changes (delta)",
        "command": "delta",
        "path": os.path.join(HOME, ".gitconfig"),
        "body": delta_body,
        "what": "Colours the before-and-after view when you compare code with git, using your theme's colours.",
    },
    "fzf": {
        "name": "Quick search list (fzf)",
        "command": "fzf",
        "path": os.path.join(GEN_DIR, "fzf.sh"),
        "body": fzf_body,
        "what": "The pop-up search list some terminal commands use, in your theme's colours.",
        "sourced": True,
    },
}

BASHRC = os.path.join(HOME, ".bashrc")
SOURCE_LINE = '[ -r "$HOME/.config/lacquer/fzf.sh" ] && . "$HOME/.config/lacquer/fzf.sh"'


def is_on(tool):
    spec = TOOLS[tool]
    text = read_capped(spec["path"]) or ""
    return BEGIN in text


def writable(path):
    """Whether this file could be written where it is."""
    target = os.path.realpath(path)
    if os.path.exists(target):
        return os.access(target, os.W_OK) and os.access(os.path.dirname(target), os.W_OK)
    folder = os.path.dirname(target)
    while folder and not os.path.exists(folder):
        folder = os.path.dirname(folder)
    return bool(folder) and os.access(folder, os.W_OK)


def apply(tool, on):
    spec = TOOLS[tool]
    text = read_or_refuse(spec["path"])
    rc = read_or_refuse(BASHRC) if spec.get("sourced") else None
    # fzf is switched on by writing two files. Check both before writing
    # either, so a refusal never leaves one written and the other not.
    for path in [spec["path"]] + ([BASHRC] if spec.get("sourced") else []):
        if not writable(path):
            raise SystemExit("%s cannot be written. Nothing was changed."
                             % path.replace(HOME, "~"))
    body = spec["body"](colors()) if on else ""
    write_text(spec["path"], replace_block(text, body))
    if spec.get("sourced"):
        write_text(BASHRC, replace_block(rc, SOURCE_LINE if on else ""))


def scan():
    out = []
    for key in sorted(TOOLS):
        spec = TOOLS[key]
        # fzf is switched on by writing two files, so both have to be readable
        # for the switch to be offered at all.
        paths = [spec["path"]] + ([BASHRC] if spec.get("sourced") else [])
        bad = [p for p in paths if os.path.lexists(p) and read_capped(p) is None]
        out.append({"id": key, "name": spec["name"], "what": spec["what"],
                    "installed": installed(spec["command"]), "on": is_on(key),
                    "readable": not bad,
                    "blockedBy": bad[0].replace(HOME, "~") if bad else "",
                    "path": spec["path"].replace(HOME, "~")})
    print(json.dumps({"tools": out}))


def main():
    argv = sys.argv[1:]
    if not argv:
        sys.exit(__doc__)
    if argv[0] == "scan":
        scan()
    elif argv[0] in ("on", "off") and len(argv) == 2 and argv[1] in TOOLS:
        apply(argv[1], argv[0] == "on")
    elif argv[0] == "reapply":
        # The theme hook calls this. One tool whose config has become
        # unreadable must not stop the others from following the new theme.
        failed = []
        for key in TOOLS:
            if is_on(key):
                try:
                    apply(key, True)
                except SystemExit as why:
                    failed.append("%s: %s" % (key, why))
        if failed:
            sys.exit("\n".join(failed))
    else:
        sys.exit(__doc__)


def _refused(err):
    """A readable line for a write the filesystem would not allow.

    A read-only ~/.config (home-manager and friends put one there), a file made
    immutable, or a full disk all arrive here as an OSError. The panel shows
    whatever comes back on stderr, and a Python traceback is no use to anybody.
    """
    home = os.environ.get("HOME", "")
    where = os.path.dirname(getattr(err, "filename", "") or "") or "that folder"
    return ("Could not write in %s: %s. Lacquer stopped there.\n"
            "A read-only folder, an immutable file or a full disk will do this."
            % (where.replace(home, "~") if home else where, err.strerror or err))


if __name__ == "__main__":
    try:
        main()
    except OSError as err:
        sys.exit(_refused(err))