@zerwiz/ymir 0.1.4 → 0.1.7

package/bin/a2a-mcp.sh

@@ -0,0 +1,133 @@
+#!/usr/bin/env bash
+# a2a-mcp.sh — install/verify the Ymir MCP servers into the harnesses so every
+# agent can use the mesh, the memory well, and the control plane at once.
+#
+#   bin/a2a-mcp.sh install            # add a2abridge + engram (+wayofteams if present) to pi + opencode
+#   bin/a2a-mcp.sh install --project  # scoped: write the REPO's .pi/mcp.json + opencode.json, never ~/.pi
+#   bin/a2a-mcp.sh show [--project]   # what is wired, in the chosen scope
+#   bin/a2a-mcp.sh --version
+#
+# Scope: default writes Pi's GLOBAL MCP list (~/.pi/agent/mcp.json). `--project`
+# keeps everything inside the repo (`.pi/mcp.json` + `opencode.json`) so a Pi used
+# in other areas is left untouched — launch it with `pi --mcp-config .pi/mcp.json`
+# to pick the repo up.
+set -u
+
+VERSION="1.0.0"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+OC="$ROOT/opencode.json"
+A2AB="${A2ABRIDGE_BIN:-$HOME/.a2abridge/bin/a2abridge}"
+DIR="${A2A_DIRECTORY:-http://127.0.0.1:7777}"
+ADVERT="${A2A_ADVERTISE_HOST:-$(tailscale ip -4 2>/dev/null | head -1)}"
+[ -n "$ADVERT" ] || ADVERT="127.0.0.1"
+
+PROJECT=0; ACTION="show"
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --project) PROJECT=1 ;;
+    -v|-V|--version) printf '%s\n' "$VERSION"; exit 0 ;;
+    -h|--help) sed -n '2,12p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    *) ACTION="$1" ;;
+  esac
+  shift
+done
+if [ "$PROJECT" = 1 ]; then PI_MCP="$ROOT/.pi/mcp.json"; else PI_MCP="$HOME/.pi/agent/mcp.json"; fi
+
+WOTES="$(command -v wayofteams-mcp 2>/dev/null || true)"
+ENGRAM_BIN="${ENGRAM_BIN:-$HOME/.local/bin/engram-mcp}"
+YMIR_HOME="${YMIR_HOME:-$HOME/Documents/Ymir}"
+ENGRAM_DB="${ENGRAM_DB:-$YMIR_HOME/memory/kaia.engram}"
+
+# The Teams plane (WayOfTeams) and Anchor memory are REMOTE MCP servers, named by
+# URL. The URL is credential-ish, so it comes from the environment — never the
+# tracked tree. Pi has no remote transport, so it reaches them through the
+# `mcp-remote` stdio bridge; OpenCode speaks `type: remote` natively.
+# The environment wins; else the private platform env, so no caller must export.
+platform_env_val() {  # <KEY>
+  local k=$1 f v
+  for f in "${YMIR_HOARD:-$YMIR_HOME/hodd}/secrets/platform.env" "$YMIR_HOME/hodd/secrets/platform.env" "$YMIR_HOME/secrets/platform.env"; do
+    [ -r "$f" ] || continue
+    v="$(grep -E "^$k=" "$f" 2>/dev/null | tail -1 | cut -d= -f2-)"
+    [ -n "$v" ] && { printf '%s' "$v"; return 0; }
+  done
+}
+TEAMS_URL="${WAYOFTEAMS_MCP_URL:-}";  [ -n "$TEAMS_URL" ]  || TEAMS_URL="$(platform_env_val WAYOFTEAMS_MCP_URL)"
+ANCHOR_URL="${ANCHOR_MCP_URL:-}";     [ -n "$ANCHOR_URL" ] || ANCHOR_URL="$(platform_env_val ANCHOR_MCP_URL)"
+
+python3 - "$ROOT" "$PI_MCP" "$OC" "$A2AB" "$DIR" "$ADVERT" "$WOTES" "$ACTION" "$ENGRAM_BIN" "$ENGRAM_DB" "$TEAMS_URL" "$ANCHOR_URL" <<'PY'
+import sys, os, json
+(root, pi_path, oc_path, a2ab, durl, advert, wotes, action, engram_bin, engram_db,
+ teams_url, anchor_url) = sys.argv[1:13]
+
+def load(p, default):
+    try: return json.load(open(p))
+    except Exception: return default
+
+ones = {
+    "a2abridge": {
+        "pi":  {"command": a2ab, "args": ["bridge"],
+                "env": {"A2A_DIRECTORY": durl, "A2A_ADVERTISE_HOST": advert}},
+        "oc":  {"type": "local", "command": [a2ab, "bridge"],
+                "environment": {"A2A_DIRECTORY": durl, "A2A_ADVERTISE_HOST": advert}},
+    },
+    "engram": {
+        "pi":  {"command": engram_bin, "args": ["--db", engram_db]},
+        "oc":  {"type": "local", "command": [engram_bin, "--db", engram_db], "environment": {}},
+    },
+}
+# The Teams plane: a URL (remote) wins over a local `wayofteams-mcp` binary.
+if teams_url:
+    ones["wayofteams"] = {
+        "pi":  {"command": "npx", "args": ["-y", "mcp-remote", teams_url]},
+        "oc":  {"type": "remote", "url": teams_url},
+    }
+elif wotes:
+    ones["wayofteams"] = {
+        "pi":  {"command": wotes, "args": ["--stdio"], "env": {"WOTEAMS_URL": os.environ.get("WOTEAMS_URL","")}},
+        "oc":  {"type": "local", "command": [wotes, "--stdio"], "environment": {"WOTEAMS_URL": os.environ.get("WOTEAMS_URL","")}},
+    }
+
+# Anchor — the memory plane, remote by URL.
+if anchor_url:
+    ones["way-of-anchor-sse"] = {
+        "pi":  {"command": "npx", "args": ["-y", "mcp-remote", anchor_url]},
+        "oc":  {"type": "remote", "url": anchor_url},
+    }
+
+if action == "show":
+    pi = load(pi_path, {}).get("mcpServers", {})
+    oc = load(oc_path, {}).get("mcp", {})
+    # Report what is ACTUALLY wired, not a fixed list: a key may come from an
+    # earlier install, a hand edit, or a server this script does not itself add.
+    names = sorted(set(ones) | set(pi) | set(oc))
+    print(f"a2a-mcp[{len(names)}]{{server,in_pi,in_opencode}}:")
+    for name in names:
+        print(f'  "{name}","{"yes" if name in pi else "no"}","{"yes" if name in oc else "no"}"')
+    if not wotes and not teams_url:
+        print('help: set WAYOFTEAMS_MCP_URL (or install wayofteams-mcp) to enable the Teams plane')
+    if not anchor_url:
+        print('help: set ANCHOR_MCP_URL to enable the Anchor memory plane')
+    sys.exit(0)
+
+if action != "install":
+    print("error: use install|show"); sys.exit(2)
+
+# pi mcp.json
+pid = load(pi_path, {"mcpServers": {}})
+pid.setdefault("mcpServers", {})
+for name, spec in ones.items():
+    pid["mcpServers"][name] = spec["pi"]
+os.makedirs(os.path.dirname(pi_path), exist_ok=True)
+json.dump(pid, open(pi_path, "w"), indent=2)
+
+# opencode.json mcp block
+ocd = load(oc_path, {"mcp": {}})
+ocd.setdefault("mcp", {})
+for name, spec in ones.items():
+    entry = spec["oc"]; entry["enabled"] = True
+    ocd["mcp"][name] = entry
+json.dump(ocd, open(oc_path, "w"), indent=2); open(oc_path, "a").write("\n")
+
+print(f'a2a-mcp[1]{{action,servers}}:\n  "install","{",".join(ones)}"')
+PY

package/bin/a2a-serve.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+# a2a-serve.py — a real A2A 1.0 server (a2a-sdk) whose agent is a seated Eindri:
+# it injects the task into the agent's chat via herdr and returns the reply.
+#
+#   a2a-serve.py <pane-or-agent> <name> <port>
+#
+# Replaces the hand-rolled server. Protocol/Agent Card/JSON-RPC are the SDK's;
+# our only job is the executor below.
+import asyncio
+import os
+import subprocess
+import sys
+import time
+
+import uvicorn
+from starlette.applications import Starlette
+
+from a2a.helpers import (
+    get_message_text,
+    new_task_from_user_message,
+    new_text_message,
+    new_text_part,
+)
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.routes import create_agent_card_routes, create_jsonrpc_routes
+from a2a.server.tasks import InMemoryTaskStore, TaskUpdater
+from a2a.types import (
+    AgentCapabilities,
+    AgentCard,
+    AgentInterface,
+    AgentSkill,
+    TaskState,
+)
+
+TARGET = sys.argv[1]
+NAME = sys.argv[2]
+PORT = int(sys.argv[3])
+WAIT = float(os.environ.get("A2A_SERVE_WAIT", "30"))
+
+
+def sh(*a: str) -> str:
+    try:
+        return subprocess.run(a, capture_output=True, text=True, timeout=90).stdout
+    except Exception:
+        return ""
+
+
+def inject_and_read(text: str) -> str:
+    """Deliver the task into the seated agent's chat, then read its reply."""
+    sh("herdr", "agent", "prompt", TARGET, text)
+    time.sleep(WAIT)
+    out = sh("herdr", "agent", "read", TARGET).strip()
+    return "\n".join(out.splitlines()[-8:]) or "(no output)"
+
+
+class EindriExecutor(AgentExecutor):
+    async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+        if context.current_task:
+            task = context.current_task
+        else:
+            task = new_task_from_user_message(context.message)
+            await event_queue.enqueue_event(task)
+        up = TaskUpdater(event_queue=event_queue, task_id=task.id, context_id=task.context_id)
+        await up.update_status(
+            state=TaskState.TASK_STATE_WORKING,
+            message=new_text_message("Delivering to the Eindri..."),
+        )
+        query = get_message_text(context.message) or ""
+        result = await asyncio.to_thread(inject_and_read, query)
+        await up.add_artifact(parts=[new_text_part(text=result, media_type="text/plain")])
+        await up.update_status(
+            state=TaskState.TASK_STATE_COMPLETED,
+            message=new_text_message(result),
+        )
+
+    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
+        raise NotImplementedError("Cancel is not supported.")
+
+
+skill = AgentSkill(
+    id="eindri", name=NAME, description=f"Ymir Eindri {NAME}",
+    input_modes=["text/plain"], output_modes=["text/plain"], tags=["ymir", "eindri"],
+)
+card = AgentCard(
+    name=NAME, description=f"Ymir Eindri {NAME}", version="1.0.0",
+    default_input_modes=["text/plain"], default_output_modes=["text/plain"],
+    capabilities=AgentCapabilities(streaming=False),
+    supported_interfaces=[AgentInterface(
+        protocol_binding="JSONRPC", url=f"http://127.0.0.1:{PORT}", protocol_version="1.0")],
+    skills=[skill],
+)
+handler = DefaultRequestHandler(
+    agent_executor=EindriExecutor(), task_store=InMemoryTaskStore(), agent_card=card,
+)
+routes: list = []
+routes.extend(create_agent_card_routes(card))
+routes.extend(create_jsonrpc_routes(handler, "/"))
+
+if __name__ == "__main__":
+    print(f"a2a-serve: {NAME} -> {TARGET} on http://127.0.0.1:{PORT}/", flush=True)
+    uvicorn.run(Starlette(routes=routes), host="127.0.0.1", port=PORT, log_level="warning")

package/bin/a2a-serve.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+# a2a-serve.sh — run the a2a-sdk A2A 1.0 server for a seated Eindri.
+#   bin/a2a-serve.sh <pane-or-agent> <name> [port]
+# The server is bin/a2a-serve.py (a2a-sdk); the executor injects via herdr.
+set -u
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PORT="${3:-7791}"
+exec python3 "$SCRIPT_DIR/a2a-serve.py" "$1" "${2:-eindri}" "$PORT"

package/bin/a2a-talk.sh

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+# a2a-talk.sh — list A2A agents and talk to one (bidirectional reply).
+#
+#   bin/a2a-talk.sh agents                 # who is registered
+#   bin/a2a-talk.sh send <peer> "<text>"   # send a task, print the reply
+#
+# Peer is matched by name (exact or prefix). Directory from A2A_DIRECTORY
+# (default http://127.0.0.1:7777). This is the proof-of-channel; pi gets the
+# same as a tool once the extension execute-API is wired.
+set -u
+DIR="${A2A_DIRECTORY:-http://127.0.0.1:7777}"
+ACTION="${1:-agents}"; shift || true
+
+agents_json() { curl -s --max-time 6 "$DIR/" 2>/dev/null; }
+
+case "$ACTION" in
+  agents)
+    agents_json | python3 -c 'import json,sys
+try:
+    d=json.load(sys.stdin); ags=d.get("served_agents",[])
+    print("a2a-agents[%d]{name,url,local}:" % len(ags))
+    for a in ags:
+        print("  \"%s\",\"%s\",\"%s\"" % (a.get("name"), a.get("url"), str(bool(a.get("local"))).lower()))
+except Exception:
+    print("error: directory unreachable")' ;;
+  send)
+    PEER="${1:-}"; shift || true; TEXT="${*:-}"
+    [ -n "$PEER" ] && [ -n "$TEXT" ] || { printf 'error: send <peer> "<text>"\n' >&2; exit 2; }
+    URL="$(agents_json | python3 -c 'import json,sys
+peer=sys.argv[1]
+try:
+    d=json.load(sys.stdin)
+    for a in d.get("served_agents",[]):
+        if a.get("name")==peer or (a.get("name") or "").startswith(peer):
+            print(a.get("url")); break
+except Exception: pass' "$PEER")"
+    [ -n "$URL" ] || { printf 'error: no peer matching "%s"\nhelp: bin/a2a-talk.sh agents\n' "$PEER" >&2; exit 1; }
+    curl -s --max-time 90 -X POST "$URL" -H 'Content-Type: application/json' \
+      -d "$(python3 -c 'import json,sys;print(json.dumps({"jsonrpc":"2.0","id":1,"method":"message/send","params":{"message":{"role":"user","parts":[{"kind":"text","text":sys.argv[1]}]}}}))' "$TEXT")" \
+      | python3 -c 'import json,sys
+try:
+    d=json.load(sys.stdin); r=d.get("result",{}); st=r.get("status",{})
+    parts=(st.get("message") or {}).get("parts",[])
+    text="\n".join(p.get("text","") for p in parts)
+    print("a2a-talk[1]{peer,state,reply}:")
+    print("  \"%s\",\"%s\",\"%s\"" % (sys.argv[1], st.get("state","?"), text))
+except Exception as e:
+    print("error: no reply:", e)' "$PEER" ;;
+  *) printf 'error: usage: bin/a2a-talk.sh agents|<send peer text>\n' >&2; exit 2 ;;
+esac

package/bin/a2abridge-ensure.sh

@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+# a2abridge-ensure.sh — ensure the A2A mesh engine (a2abridge) is present,
+# its directory daemon is up, and its MCP wiring is in the harnesses.
+#
+# **Ratatoskr** runs on the open A2A 1.0 protocol via the MIT-licensed
+# **a2abridge** engine (github.com/vbcherepanov/a2abridge) — one binary that
+# is directory, bridge, service, cert, and doctor. The engine keeps its
+# product name; the mesh Ymir calls Ratatoskr is the same wire.
+#
+# The engine's official installer writes IDE configs; Ymir owns the harness
+# wiring itself (bin/a2a-mcp.sh → pi + opencode), so this ensure installs the
+# engine with A2A_NO_IDE=1 and never lets the engine edit IDE configs.
+#
+# Usage:
+#   a2abridge-ensure.sh status
+#   a2abridge-ensure.sh ensure [--install]
+#   a2abridge-ensure.sh install
+#   a2abridge-ensure.sh --version
+#
+# Exit: 0 ready (or made ready), 1 not ready, 2 usage.
+set -u
+
+VERSION="1.0.0"
+A2AB="${A2ABRIDGE_BIN:-$HOME/.a2abridge/bin/a2abridge}"
+PREFIX="${A2AB%/bin/a2abridge}"
+VERSION_TAG="${A2ABRIDGE_VERSION:-v3.0.0}"
+DIR_URL="${A2A_DIRECTORY_URL:-http://127.0.0.1:7777}"
+UNIT="$HOME/.config/systemd/user/a2abridge-directory.service"
+
+case "${1-}" in -v|-V|--version) printf '%s\n' "$VERSION"; exit 0 ;; -h|--help|"") sed -n '2,16p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;; esac
+CMD="${1-}"; shift || true
+DO_INSTALL=0
+case "$CMD" in ensure) ;; status|install) ;; *) printf 'error: unknown command %s\nhelp: bin/a2abridge-ensure.sh [status|ensure|install]\n' "$CMD" >&2; exit 2 ;; esac
+while [ $# -gt 0 ]; do case "$1" in --install) DO_INSTALL=1; shift ;; *) shift ;; esac; done
+[ "$CMD" = install ] && DO_INSTALL=1
+
+have() { command -v "$1" >/dev/null 2>&1; }
+
+engine_present() { [ -x "$A2AB" ]; }
+service_up() {
+  have systemctl && systemctl --user is-active --quiet a2abridge-directory 2>/dev/null
+}
+directory_up() { curl -s --max-time 3 -o /dev/null "$DIR_URL"; }
+
+install_engine() {
+  local tmp
+  tmp="$(mktemp -d)"
+  # Guard the var: a RETURN trap can fire after the function's locals are gone,
+  # and `set -u` would then abort with "tmp: unbound variable".
+  trap 'rm -rf "${tmp:-}"' RETURN
+  if ! curl -fsSL "https://raw.githubusercontent.com/vbcherepanov/a2abridge/main/install.sh" -o "$tmp/install.sh" 2>/dev/null; then
+    return 1
+  fi
+  # The engine's own installer fails resolving the latest release on some
+  # hosts (curl | grep pipe); pin the tag so the download always resolves.
+  A2A_NO_IDE=1 bash "$tmp/install.sh" --version "$VERSION_TAG" >/dev/null 2>&1
+}
+
+patch_unit_logs() {
+  # The engine's unit writes StandardOutput/Error to /var/log, which a
+  # systemd --user service cannot touch — the daemon dies at STDOUT setup.
+  # Point both at the journal unless they are already user-safe.
+  [ -f "$UNIT" ] || return 0
+  # grep, not rg: the patch must apply on any host, and ripgrep is not guaranteed.
+  if grep -qE '^Standard(Output|Error)=file:/var/log' "$UNIT" 2>/dev/null; then
+    sed -i 's|^StandardOutput=file:.*|StandardOutput=journal|; s|^StandardError=file:.*|StandardError=journal|' "$UNIT"
+    systemctl --user daemon-reload >/dev/null 2>&1 || true
+    systemctl --user restart a2abridge-directory >/dev/null 2>&1 || true
+  fi
+}
+
+status() {
+  local eng srvc dir
+  if engine_present; then eng="$("$A2AB" version 2>/dev/null | head -1)"; else eng="absent"; fi
+  if service_up; then srvc="up"; else srvc="down"; fi
+  if directory_up; then dir="up"; else dir="down"; fi
+  printf 'a2abridge[1]{engine,directory,service}:\n  "%s","%s","%s"\n' "$eng" "$dir" "$srvc"
+}
+
+ensure() {
+  local changed=0
+  if ! engine_present; then
+    if [ "$DO_INSTALL" = 1 ]; then
+      install_engine || { printf 'a2abridge: install failed (offline?)\nhelp: re-run when the network returns\n' >&2; return 1; }
+      changed=1
+    else
+      printf 'a2abridge: engine absent — run bin/a2abridge-ensure.sh ensure --install\n' >&2
+      return 1
+    fi
+  fi
+  patch_unit_logs
+  if ! service_up; then
+    systemctl --user start a2abridge-directory >/dev/null 2>&1 || true
+    sleep 1
+  fi
+  if ! directory_up; then
+    printf 'a2abridge: directory not answering on A2A_DIRECTORY\nhelp: systemctl --user status a2abridge-directory\n' >&2
+    return 1
+  fi
+  status
+  return 0
+}
+
+case "$CMD" in
+  status) status ;;
+  install) DO_INSTALL=1; ensure ;;
+  ensure) ensure ;;
+esac

package/bin/agent-run.sh

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# agent-run.sh — run one agent's errand through the harness the Allfather chose.
+#
+#   bin/agent-run.sh <agent> "<task>"
+#
+# The harness and model come from config/agents.yaml via bin/agents-config.sh.
+# Any harness on PATH can be chosen per agent (pi | opencode | claude | codex |
+# gemini | hermes | …), so the same smith can be run on whichever CLI you prefer.
+set -u
+
+VERSION="1.0.0"
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+case "${1-}" in -v|-V|--version) printf '%s\n' "$VERSION"; exit 0 ;; -h|--help|"") sed -n '2,9p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;; esac
+
+AGENT="${1:-}"; shift || true
+TASK="${*:-}"
+[ -n "$AGENT" ] && [ -n "$TASK" ] || { printf 'error: usage: bin/agent-run.sh <agent> "<task>"\n' >&2; exit 2; }
+
+HARNESS="$("$SCRIPT_DIR/agents-config.sh" get "$AGENT" harness 2>/dev/null)"
+MODEL="$("$SCRIPT_DIR/agents-config.sh" get "$AGENT" model 2>/dev/null)"
+[ -n "$HARNESS" ] || { printf 'error: unknown agent %s\nhelp: bin/agents-config.sh show\n' "$AGENT" >&2; exit 1; }
+
+have() { command -v "$1" >/dev/null 2>&1; }
+
+run() {
+  case "$HARNESS" in
+    pi)       exec pi --print --model "$MODEL" "$TASK" ;;
+    opencode) # `--agent` works when the agent is a primary (apply emits primaries)
+              opencode run --agent "$AGENT" "$TASK" && exit 0
+              exec opencode run -m "$MODEL" "$TASK" ;;
+    claude)   exec claude -p --model "$MODEL" "$TASK" ;;
+    codex)    exec codex exec "$TASK" ;;
+    gemini)   exec gemini -p "$TASK" ;;
+    qwen)     exec qwen -p "$TASK" ;;
+    hermes)   exec hermes "$TASK" ;;
+    *)        printf 'error: harness not wired: %s\nhelp: pick pi|opencode|claude|codex|gemini|qwen|hermes in config/agents.yaml\n' "$HARNESS" >&2; exit 1 ;;
+  esac
+}
+
+have "$HARNESS" || { printf 'error: harness %s is not on PATH (%s)\n' "$HARNESS" "$AGENT" >&2; exit 1; }
+printf 'agent-run[1]{agent,harness,model}:\n  "%s","%s","%s"\n' "$AGENT" "$HARNESS" "$MODEL" >&2
+run