@litfamily/lithermes 1.0.0

package/assets/lithermes-plugin/knowledge_tools.py

@@ -0,0 +1,130 @@
+"""Hermes tool and hook adapter for structured Wikify knowledge events."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from collections import OrderedDict
+from pathlib import Path
+from typing import Any
+
+from . import knowledge
+
+
+TOOL_NAME = "lithermes_knowledge_capture"
+TOOLSET = "lithermes-knowledge"
+_RECEIPTS: OrderedDict[str, dict[str, str]] = OrderedDict()
+_MAX_RECEIPTS = 64
+_HOST_WORKSPACE_KEY = "workspace"
+
+
+def _workspace_from_kwargs(kwargs: dict[str, Any]) -> Path | None:
+    if _HOST_WORKSPACE_KEY not in kwargs:
+        return Path.cwd()
+    value = kwargs.get(_HOST_WORKSPACE_KEY)
+    if not isinstance(value, (str, os.PathLike)):
+        return None
+    raw = os.fsdecode(os.fspath(value)).strip()
+    return Path(raw) if raw else None
+
+
+def _session_identity(kwargs: dict[str, Any]) -> str:
+    return str(kwargs.get("session_id") or kwargs.get("task_id") or "")
+
+
+def _workspace_identity(workspace: Path) -> str:
+    try:
+        return str(knowledge._canonical_workspace(workspace))
+    except (OSError, ValueError):
+        return str(workspace.absolute())
+
+
+def _event_key(event: object, *, workspace: Path, session_id: str) -> str:
+    encoded = json.dumps(
+        {
+            "event": event,
+            "session_id": session_id,
+            "workspace": _workspace_identity(workspace),
+        },
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+        default=str,
+    ).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def pre_tool_call(**kwargs: Any) -> bool:
+    if str(kwargs.get("tool_name") or "") != TOOL_NAME:
+        return False
+    args = kwargs.get("args")
+    event = args.get("event") if isinstance(args, dict) else None
+    workspace = _workspace_from_kwargs(kwargs)
+    session_id = _session_identity(kwargs)
+    if workspace is None:
+        return True
+    receipt = knowledge.capture_event(workspace, event)
+    key = _event_key(event, workspace=workspace, session_id=session_id)
+    _RECEIPTS[key] = receipt
+    _RECEIPTS.move_to_end(key)
+    while len(_RECEIPTS) > _MAX_RECEIPTS:
+        _RECEIPTS.popitem(last=False)
+    return True
+
+
+def tool_capture(args: dict | None = None, **kwargs: Any) -> str:
+    payload = args if isinstance(args, dict) else {}
+    event = payload.get("event")
+    workspace = _workspace_from_kwargs(kwargs)
+    session_id = _session_identity(kwargs)
+    if workspace is None:
+        return json.dumps({"status": "error", "reason": "workspace-unavailable"}, ensure_ascii=True, sort_keys=True)
+    receipt = _RECEIPTS.pop(
+        _event_key(event, workspace=workspace, session_id=session_id),
+        None,
+    )
+    if receipt is None:
+        receipt = knowledge.capture_event(workspace, event)
+    return json.dumps(receipt, ensure_ascii=True, sort_keys=True)
+
+
+TOOL_SPEC = {
+    "name": TOOL_NAME,
+    "toolset": TOOLSET,
+    "description": (
+        "Capture one already-structured local Wikify event as review-needed. "
+        "Never submit chat, source bodies, fetched text, credentials, secrets, tokens, "
+        "or instruction-shaped text. Acceptance requires an explicit knowledge save or review command."
+    ),
+    "handler": tool_capture,
+    "schema": {
+        "type": "object",
+        "properties": {
+            "event": {
+                "type": "object",
+                "properties": {
+                    "kind": {"type": "string", "enum": sorted(knowledge.KINDS)},
+                    "text": {"type": "string", "maxLength": knowledge.TEXT_MAX_BYTES},
+                    "source": {"type": "string", "enum": sorted(knowledge.SOURCES)},
+                    "evidence_ref": {"type": "string", "maxLength": knowledge.EVIDENCE_MAX_BYTES},
+                },
+                "required": ["kind", "text", "source", "evidence_ref"],
+                "additionalProperties": False,
+            }
+        },
+        "required": ["event"],
+        "additionalProperties": False,
+    },
+}
+
+
+def register_tools(ctx) -> list[str]:
+    ctx.register_tool(
+        name=TOOL_SPEC["name"],
+        toolset=TOOL_SPEC["toolset"],
+        schema=TOOL_SPEC["schema"],
+        handler=TOOL_SPEC["handler"],
+        description=TOOL_SPEC["description"],
+    )
+    return [TOOL_NAME]

package/assets/lithermes-plugin/lit_mark.py

@@ -0,0 +1,140 @@
+"""Canonical LIT rows, terminal policy, and native Hermes ignition surfaces."""
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+_ROWS = json.loads(Path(__file__).with_name("lit_mark_rows.json").read_text(encoding="utf-8"))
+standard = [row["text"] for row in _ROWS["standard"]]
+banner = [row["text"] for row in _ROWS["banner"]]
+micro = [row["text"] for row in _ROWS["micro"]]
+_GLYPHS = frozenset("█▓▀▄▌▐▖▗▘▝▙▛▜▟▚▞")
+_INDEXED = {"#FF6337": 203, "#D7F75B": 191, "#F2EFDF": 230}
+
+
+def lockup(productName: str, rows=None) -> list[str]:
+    if not isinstance(productName, str) or not re.fullmatch(r"[a-zA-Z0-9 .·_-]+", productName):
+        raise ValueError("product name must be a plain single line")
+    rows = standard if rows is None else rows
+    column = max(map(len, rows)) + 8
+    return [row.ljust(column) + productName if i == len(rows) // 2 else row for i, row in enumerate(rows)]
+
+
+def _cells_for(rows):
+    return next((cells for cells in _ROWS.values() if len(cells) == len(rows)
+                 and all(row.startswith(cell["text"]) for row, cell in zip(rows, cells))), None)
+
+
+def colorize(rows, options=None, *, mode=None, shadow=None) -> list[str]:
+    options = options or {}
+    mode = mode or options.get("mode", "none")
+    if mode not in {"none", "256", "truecolor"}:
+        raise ValueError("invalid color mode")
+    if mode == "none":
+        return list(rows)
+    # Keep the old shadow keyword callable; the flat approved mark has no shadow.
+    cells = _cells_for(rows)
+    output = []
+    for i, row in enumerate(rows):
+        painted = []
+        for column, ch in enumerate(row):
+            hex_color = (cells[i]["colors"][column] if column < len(cells[i]["colors"]) else None) if cells else "#F2EFDF"
+            if ch not in _GLYPHS or not hex_color:
+                painted.append(ch)
+                continue
+            ink = f"38;5;{_INDEXED[hex_color]}" if mode == "256" else "38;2;" + ";".join(
+                str(int(hex_color[offset:offset + 2], 16)) for offset in (1, 3, 5))
+            painted.append(f"\x1b[{ink}m{ch}\x1b[0m")
+        output.append("".join(painted))
+    return output
+
+
+def utf8_terminal(env=None) -> bool:
+    env = os.environ if env is None else env
+    locale = env.get("LC_ALL") or env.get("LC_CTYPE") or env.get("LANG", "")
+    return env.get("TERM") != "dumb" and (not locale or bool(re.search(r"utf-?8", locale, re.I)))
+
+
+def color_mode(*, stream=None, env=None, json=False) -> str:
+    env = os.environ if env is None else env
+    stream = sys.stdout if stream is None else stream
+    if json or "NO_COLOR" in env or "CI" in env or not stream.isatty() or not utf8_terminal(env):
+        return "none"
+    return "truecolor" if re.search(r"truecolor|24bit", env.get("COLORTERM", ""), re.I) or "direct" in env.get("TERM", "").lower() else "256"
+
+
+def render(rows, *, env=None, stream=None, json=False, mode=None) -> list[str]:
+    if not utf8_terminal(env):
+        return ["LIT"]
+    detected = color_mode(env=env, stream=stream, json=json)
+    return colorize(rows, mode="none" if detected == "none" else mode or detected)
+
+
+def discipline(route: str) -> str:
+    canonical = {"lit": "litwork", "litwork-loop": "lit-loop", "litwork-plan": "lit-plan",
+                 "durable-workflow": "lit-loop", "kanban-team": "lit-team",
+                 "korean-prose-cleanup": "lit-korean"}.get(route, route)
+    if not re.fullmatch(r"[a-z0-9]+(?:-[a-z0-9]+)*", canonical):
+        raise ValueError("invalid route discipline")
+    return canonical
+
+
+def probe_line(route: str) -> str:
+    return f"▲ LIT · {discipline(route)}"
+
+
+def probe_contract(route: str) -> str:
+    return (f"Begin your reply with exactly this one model-emitted line: `{probe_line(route)}`\n"
+            "Emit it once, without markup. This route's discipline overrides any generic skill probe. "
+            "The harness renders the mark separately; do not draw or repeat it.")
+
+
+def acknowledgement(route: str, *, color=False, **options) -> str:
+    # Slash display accepts ANSI; natural reply transforms enter Markdown and
+    # transcripts, where the mark remains plain. Never color the model probe.
+    rows = render(micro, mode=None if color else "none", **options)
+    label = f"lithermes · {discipline(route)}"
+    if rows == ["LIT"]:
+        return f"LIT\n{label}"
+    rows[len(rows) // 2] += "  " + label
+    return "\n".join(rows)
+
+
+def acknowledge_reply(route: str, response: str) -> str:
+    # The host keeps only the suffix when a transformed response starts with
+    # the streamed body. Indented plain lines preserve MICRO rows in Markdown
+    # without replaying the model response or adding a fence.
+    suffix = "\n".join(f"    {row}" for row in acknowledgement(route).splitlines())
+    return f"{response}\n\n{suffix}" if response else suffix
+
+
+def skin_logo(*, env=None, stream=None, json=False) -> str:
+    if not utf8_terminal(env):
+        return "LIT"
+    mode = color_mode(env=env, stream=stream, json=json)
+    if mode == "none":
+        return "\n".join(standard)
+    output = []
+    for row in _ROWS["standard"]:
+        painted = []
+        for ch, hex_color in zip(row["text"], row["colors"]):
+            if hex_color:
+                ink = hex_color if mode == "truecolor" else f"color({_INDEXED[hex_color]})"
+                painted.append(f"[{ink}]{ch}[/]")
+            else:
+                painted.append(ch)
+        output.append("".join(painted))
+    return "\n".join(output)
+
+
+def configure_welcome_skin() -> None:
+    """Adjust the active managed skin in memory; the host draws it at welcome."""
+    try:
+        from hermes_cli.skin_engine import get_active_skin, get_active_skin_name
+    except ImportError:
+        return
+    if get_active_skin_name().startswith("lithermes-"):
+        get_active_skin().banner_logo = skin_logo(json="--json" in sys.argv)