agent-wire-cli 0.2.1__py3-none-any.whl

agent_wire/installers/client_installer.py

@@ -0,0 +1,315 @@
+"""Install agent-wire into agent clients, keeping config, cache and vault inside each client's folder.
+
+Existing configs are merged, never clobbered: other servers and keys survive, a file that isn't
+valid JSON/TOML is refused instead of overwritten, and re-running is idempotent.
+"""
+
+import json
+import os
+import re
+import sys
+import tomllib
+from dataclasses import dataclass, field
+from importlib import metadata, resources
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+
+SERVER = "agent_wire"
+CLIENTS = ("claude-code", "codex", "hermes", "antigravity", "claude-desktop", "peridot", "cursor",
+           "windsurf", "vscode", "roo", "gemini")  # fmt: skip
+ASSETS = {
+    "SKILL.md": "skills/agent-wire/SKILL.md",
+    "wire-worker.md": "agents/wire-worker.md",
+    "cursor_rule.mdc": "manifests/cursor_rule.mdc",
+    "windsurf_rules.md": "manifests/windsurf_rules.md",
+    "hermes_skill.md": "manifests/hermes_skill.md",
+}
+
+
+@dataclass
+class Result:
+    client: str
+    files: list[Path] = field(default_factory=list)
+    notes: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Target:
+    project: Path
+    home: Path
+    profile: str
+    global_: bool
+    dry_run: bool
+
+
+def asset(name: str) -> str:
+    """Copy bundled in the wheel, else the source checkout (editable / dev installs)."""
+    packaged = resources.files("agent_wire").joinpath("assets", name)
+    if packaged.is_file():
+        return packaged.read_text(encoding="utf-8")
+    return (Path(__file__).resolve().parents[3] / ASSETS[name]).read_text(encoding="utf-8")
+
+
+def _body(md: str) -> str:
+    """Markdown without its YAML front matter."""
+    return re.sub(r"\A---\n.*?\n---\n+", "", md, flags=re.DOTALL)
+
+
+def install_source() -> str | None:
+    """Where uvx should fetch agent-wire from, mirroring how it was installed (PyPI: agent-wire-cli).
+
+    A local checkout -> its path; a git install -> `git+<url>[@rev]`; a registry install -> None.
+    """
+    try:
+        raw = metadata.distribution("agent-wire-cli").read_text("direct_url.json")
+    except metadata.PackageNotFoundError:
+        return None
+    info = json.loads(raw) if raw else {}
+    url = info.get("url", "")
+    if "vcs_info" in info:
+        rev = info["vcs_info"].get("requested_revision")
+        return f"git+{url}" + (f"@{rev}" if rev else "")
+    if not url.startswith("file:"):
+        return None
+    path = unquote(urlsplit(url).path)
+    if re.match(r"^/[A-Za-z]:", path):  # file:///E:/agent-wire on Windows
+        path = path[1:]
+    return str(Path(path))
+
+
+def server_entry(profile: str, wire_home: Path) -> dict:
+    """uvx for registry/git installs (cached env); `uv run` for a local checkout, because
+    `uvx --from <path>` rebuilds the environment on every start and blows client connect timeouts."""
+    src = install_source()
+    tail = ["--profile", "local"] if profile == "local" else []
+    env = {"WIRE_HOME": str(wire_home)}
+    if src and not src.startswith("git+"):
+        args = ["run", "--quiet", "--directory", src, "--frozen", "wire", "serve", *tail]
+        return {"command": "uv", "args": args, "env": env}
+    args = (["--from", src] if src else []) + ["agent-wire-cli", "serve", *tail]
+    return {"command": "uvx", "args": args, "env": env}
+
+
+# ---- file helpers -------------------------------------------------------------------------------
+def _write(path: Path, text: str, t: Target, r: Result) -> None:
+    if not t.dry_run:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text, encoding="utf-8")
+    r.files.append(path)
+
+
+def _read(path: Path) -> str:
+    return path.read_text(encoding="utf-8") if path.exists() else ""
+
+
+def _merge_json(path: Path, section: str, entry: dict, t: Target, r: Result) -> None:
+    raw = _read(path).strip()
+    try:
+        data = json.loads(raw) if raw else {}
+    except json.JSONDecodeError as e:
+        raise ValueError(
+            f"{path} is not plain JSON ({e.msg}); add agent_wire by hand or fix the file"
+        ) from e
+    if not isinstance(data, dict):
+        raise ValueError(f"{path} does not hold a JSON object")  # noqa: TRY004 - CLI reports ValueError
+    data.setdefault(section, {})[SERVER] = entry
+    _write(path, json.dumps(data, indent=2, ensure_ascii=False) + "\n", t, r)
+
+
+def _toml_block(entry: dict) -> str:
+    args = ", ".join(json.dumps(a) for a in entry["args"])
+    env = ", ".join(f"{k} = {json.dumps(v)}" for k, v in entry["env"].items())
+    return f"[mcp_servers.{SERVER}]\ncommand = {json.dumps(entry['command'])}\nargs = [{args}]\nenv = {{ {env} }}\n"
+
+
+def _merge_toml(path: Path, entry: dict, t: Target, r: Result) -> None:
+    text = _read(path)
+    block = _toml_block(entry)
+    existing = re.compile(rf"(?ms)^\[mcp_servers\.{SERVER}\]\n.*?(?=^\[|\Z)")
+    if existing.search(text):
+        text = existing.sub(lambda _: block + "\n", text, count=1).rstrip() + "\n"
+    else:
+        text = (text.rstrip() + "\n\n" if text.strip() else "") + block
+    try:
+        tomllib.loads(text)  # never leave Codex a config it can't parse
+    except tomllib.TOMLDecodeError as e:
+        raise ValueError(
+            f"{path}: merged config would not parse ({e}); add agent_wire by hand"
+        ) from e
+    _write(path, text, t, r)
+
+
+def _merge_hermes_yaml(path: Path, entry: dict, t: Target, r: Result) -> None:
+    text = _read(path)
+    if re.search(rf"(?m)^\s+{SERVER}:\s*$", text):
+        r.notes.append(f"{path} already registers {SERVER}; left unchanged")
+        return
+    block = (f"  {SERVER}:\n    command: {entry['command']}\n    args: {json.dumps(entry['args'])}\n"
+             f"    env:\n      WIRE_HOME: {json.dumps(entry['env']['WIRE_HOME'])}\n")  # fmt: skip
+    if re.search(r"(?m)^mcp_servers:\s*$", text):
+        text = re.sub(r"(?m)^mcp_servers:[ \t]*\n", lambda m: m[0] + block, text, count=1)
+    elif re.search(r"(?m)^mcp_servers:", text):
+        raise ValueError(f"{path}: mcp_servers uses inline YAML; add agent_wire by hand")
+    else:
+        text = (text.rstrip() + "\n\n" if text.strip() else "") + "mcp_servers:\n" + block
+    _write(path, text, t, r)
+
+
+def _desktop_dir(home: Path) -> Path:
+    if sys.platform == "win32":
+        roaming = (
+            Path(os.environ["APPDATA"])
+            if os.environ.get("APPDATA") and home == Path.home()
+            else home / "AppData" / "Roaming"
+        )
+        return roaming / "Claude"
+    if sys.platform == "darwin":
+        return home / "Library" / "Application Support" / "Claude"
+    return home / ".config" / "Claude"
+
+
+# ---- clients ------------------------------------------------------------------------------------
+def _claude_code(t: Target, r: Result) -> None:
+    base = (t.home if t.global_ else t.project) / ".claude"
+    entry = server_entry(t.profile, base / ".wire")
+    _merge_json(
+        t.home / ".claude.json" if t.global_ else t.project / ".mcp.json", "mcpServers", entry, t, r
+    )
+    _write(base / "skills" / "agent-wire" / "SKILL.md", asset("SKILL.md"), t, r)
+    _write(base / "agents" / "wire-worker.md", asset("wire-worker.md"), t, r)
+
+
+def _codex(t: Target, r: Result) -> None:
+    base = (
+        t.project / ".codex"
+        if not t.global_ and (t.project / ".codex").is_dir()
+        else t.home / ".codex"
+    )
+    _merge_toml(base / "config.toml", server_entry(t.profile, base / ".wire"), t, r)
+    _write(base / "skills" / "agent-wire" / "SKILL.md", asset("SKILL.md"), t, r)
+    if t.profile != "local":
+        r.notes.append(
+            "Codex Go plan: re-run with --profile local to cap tool output at 800 tokens"
+        )
+
+
+def _hermes(t: Target, r: Result) -> None:
+    base = t.home / ".hermes"
+    _merge_hermes_yaml(base / "config.yaml", server_entry(t.profile, base / ".wire"), t, r)
+    _write(base / "skills" / "agent-wire" / "SKILL.md", asset("hermes_skill.md"), t, r)
+
+
+def _antigravity(t: Target, r: Result) -> None:
+    base = (t.home / ".gemini" / "antigravity") if t.global_ else (t.project / ".agent")
+    entry = server_entry(t.profile, base / ".wire")
+    _merge_json(t.home / ".gemini" / "antigravity" / "mcp_config.json", "mcpServers", entry, t, r)
+    _write(base / "skills" / "agent-wire" / "SKILL.md", asset("SKILL.md"), t, r)
+    _write(base / "agents" / "wire-worker.md", asset("wire-worker.md"), t, r)
+
+
+def _claude_desktop(t: Target, r: Result) -> None:
+    base = _desktop_dir(t.home)
+    _merge_json(
+        base / "claude_desktop_config.json",
+        "mcpServers",
+        server_entry(t.profile, base / ".wire"),
+        t,
+        r,
+    )
+    r.notes.append("restart Claude Desktop to load the server")
+
+
+def _peridot(t: Target, r: Result) -> None:
+    base = (t.home if t.global_ else t.project) / ".peridot"
+    _merge_json(base / "mcp.json", "mcpServers", server_entry("local", base / ".wire"), t, r)
+    r.notes.append("peridot always uses the local (8 GB VRAM) profile")
+
+
+def _cursor(t: Target, r: Result) -> None:
+    base = (t.home if t.global_ else t.project) / ".cursor"
+    _merge_json(base / "mcp.json", "mcpServers", server_entry(t.profile, base / ".wire"), t, r)
+    if not t.global_:
+        _write(base / "rules" / "agent-wire.mdc", asset("cursor_rule.mdc"), t, r)
+
+
+def _windsurf(t: Target, r: Result) -> None:
+    base = t.home / ".codeium" / "windsurf"
+    _merge_json(
+        base / "mcp_config.json", "mcpServers", server_entry(t.profile, base / ".wire"), t, r
+    )
+    if not t.global_:
+        _write(
+            t.project / ".windsurf" / "rules" / "agent-wire.md", asset("windsurf_rules.md"), t, r
+        )
+
+
+def _vscode(t: Target, r: Result) -> None:
+    base = t.project / ".vscode"
+    entry = {"type": "stdio", **server_entry(t.profile, base / ".wire")}
+    _merge_json(base / "mcp.json", "servers", entry, t, r)
+    if t.global_:
+        r.notes.append("VS Code MCP config is per-workspace; wrote .vscode/mcp.json in the project")
+
+
+def _roo(t: Target, r: Result) -> None:
+    base = t.project / ".roo"
+    _merge_json(base / "mcp.json", "mcpServers", server_entry(t.profile, base / ".wire"), t, r)
+    _write(base / "rules" / "agent-wire.md", _body(asset("SKILL.md")), t, r)
+
+
+def _gemini(t: Target, r: Result) -> None:
+    base = t.home / ".gemini" / "extensions" / "agent-wire"
+    manifest = {
+        "name": "agent-wire",
+        "version": "0.1.0",
+        "description": "Live web and platform access: token-compressed, privacy-firewalled.",
+        "contextFileName": "GEMINI.md",
+        "mcpServers": {SERVER: server_entry(t.profile, base / ".wire")},
+    }
+    _write(base / "gemini-extension.json", json.dumps(manifest, indent=2) + "\n", t, r)
+    _write(base / "GEMINI.md", _body(asset("SKILL.md")), t, r)
+
+
+WRITERS = {
+    "claude-code": _claude_code, "codex": _codex, "hermes": _hermes, "antigravity": _antigravity,
+    "claude-desktop": _claude_desktop, "peridot": _peridot, "cursor": _cursor,
+    "windsurf": _windsurf, "vscode": _vscode, "roo": _roo, "gemini": _gemini,
+}  # fmt: skip
+
+
+def detect(project: Path, home: Path) -> list[str]:
+    markers = {
+        "claude-code": [project / ".claude", home / ".claude"],
+        "codex": [project / ".codex", home / ".codex"],
+        "hermes": [home / ".hermes"],
+        "antigravity": [project / ".agent", home / ".gemini" / "antigravity"],
+        "claude-desktop": [_desktop_dir(home)],
+        "peridot": [project / ".peridot"],
+        "cursor": [project / ".cursor", home / ".cursor"],
+        "windsurf": [project / ".windsurf", home / ".codeium" / "windsurf"],
+        "vscode": [project / ".vscode"],
+        "roo": [project / ".roo"],
+        "gemini": [home / ".gemini" / "extensions"],
+    }
+    return [c for c, paths in markers.items() if any(p.exists() for p in paths)] or ["claude-code"]
+
+
+def install(client: str, *, project: Path, home: Path, profile: str = "standard",
+            global_: bool = False, dry_run: bool = False) -> list[Result]:  # fmt: skip
+    if client == "all":
+        names = list(CLIENTS)
+    elif client == "auto":
+        names = detect(project, home)
+    elif client in WRITERS:
+        names = [client]
+    else:
+        raise ValueError(
+            f"unknown client {client!r}; choose auto, all, or one of: {', '.join(CLIENTS)}"
+        )
+    target = Target(project, home, profile, global_, dry_run)
+    results = []
+    for name in names:
+        r = Result(name)
+        WRITERS[name](target, r)
+        results.append(r)
+    return results

agent_wire/media/audio_transcriber.py

@@ -0,0 +1,77 @@
+"""Optional transcription: local faster-whisper (GPU/CPU) or an OpenAI-compatible API, all in memory."""
+
+import asyncio
+import importlib.util
+import io
+import os
+
+from curl_cffi import CurlMime
+
+from agent_wire.engine.http_pool import HttpPool
+from agent_wire.firewall.outbound_privacy import parse_json
+from agent_wire.media.subtitle_cleaner import to_paragraphs
+
+MAX_AUDIO_BYTES = 200 * 1024 * 1024
+DEFAULT_API = "https://api.openai.com/v1/audio/transcriptions"
+
+
+class TranscriptionUnavailable(Exception):
+    pass
+
+
+def enabled() -> bool:
+    return os.environ.get("WIRE_TRANSCRIBE") == "1"
+
+
+def backend() -> str | None:
+    if importlib.util.find_spec("faster_whisper"):
+        return "local"
+    if os.environ.get("WIRE_TRANSCRIBE_API_KEY"):
+        return "api"
+    return None
+
+
+async def transcribe(pool: HttpPool, audio_url: str) -> str:
+    kind = backend()
+    if not kind:
+        raise TranscriptionUnavailable(
+            "install agent-wire-cli[local-whisper] or set WIRE_TRANSCRIBE_API_KEY for an OpenAI-compatible API"
+        )
+    f = await pool.get(audio_url, impersonate=None, timeout=300)
+    if not f.ok or len(f.content) > MAX_AUDIO_BYTES:
+        raise TranscriptionUnavailable(
+            f"audio download failed or too large ({len(f.content)} bytes)"
+        )
+    if kind == "local":
+        return await asyncio.to_thread(_local, f.content)
+    return await _api(pool, f.content, audio_url.rsplit("/", 1)[-1].split("?")[0] or "audio.mp3")
+
+
+def _local(audio: bytes) -> str:
+    from faster_whisper import WhisperModel
+
+    model = WhisperModel(
+        os.environ.get("WIRE_WHISPER_MODEL", "small"), device="auto", compute_type="auto"
+    )
+    segments, _ = model.transcribe(io.BytesIO(audio), vad_filter=True)
+    return to_paragraphs([(s.start, s.text.strip()) for s in segments])
+
+
+async def _api(pool: HttpPool, audio: bytes, filename: str) -> str:
+    # Opt-in only: this uploads the (public) audio to the configured provider.
+    mime = CurlMime()
+    mime.addpart(name="model", data=os.environ.get("WIRE_TRANSCRIBE_MODEL", "whisper-1").encode())
+    mime.addpart(
+        name="file", filename=filename, content_type="application/octet-stream", data=audio
+    )
+    try:
+        f = await pool.get(
+            os.environ.get("WIRE_TRANSCRIBE_URL", DEFAULT_API), method="POST", impersonate=None,
+            headers={"Authorization": f"Bearer {os.environ['WIRE_TRANSCRIBE_API_KEY']}"},
+            multipart=mime, timeout=600,
+        )  # fmt: skip
+    finally:
+        mime.close()
+    if not f.ok:
+        raise TranscriptionUnavailable(f"transcription API returned HTTP {f.status}")
+    return parse_json(f.content).get("text", "")

agent_wire/media/subtitle_cleaner.py

@@ -0,0 +1,102 @@
+"""VTT / SRT / JSON3 / timedtext XML -> clean paragraphs (no timestamps, no rolling duplicates)."""
+
+import html
+import re
+
+import orjson
+
+_TIME = r"(?:\d+:)?\d{1,2}:\d{2}[.,]\d{3}"
+_CUE = re.compile(rf"^({_TIME})\s*-->\s*({_TIME})")
+_INLINE_TAG = re.compile(r"<[^>]+>")
+_XML_CUE = re.compile(
+    r'<(?:text|p)\b[^>]*?\b(?:start|t)="([\d.]+)"[^>]*>(.*?)</(?:text|p)>', re.DOTALL
+)
+_SENTENCE_END = re.compile(r"[.!?。！？…]$")
+CHAPTER_LINE = re.compile(r"^\s*((?:\d{1,2}:)?\d{1,2}:\d{2})\s*[-–—:]?\s+(.+?)\s*$")
+
+GAP_BREAK_S = 2.5
+PARAGRAPH_CHARS = 600
+
+
+def _seconds(stamp: str) -> float:
+    parts = stamp.replace(",", ".").split(":")
+    return sum(float(p) * 60**i for i, p in enumerate(reversed(parts)))
+
+
+def parse_captions(raw: str | bytes) -> list[tuple[float, str]]:
+    text = raw.decode("utf-8", errors="replace") if isinstance(raw, bytes) else raw
+    text = text.lstrip("").strip()
+    if text.startswith("{"):
+        segs = []
+        for ev in orjson.loads(text).get("events", []):
+            line = "".join(s.get("utf8", "") for s in ev.get("segs") or [])
+            if line.strip():
+                segs.append((ev.get("tStartMs", 0) / 1000, line))
+        return _clean(segs)
+    if text.startswith("<"):
+        return _clean([(float(t) / (1000 if "." not in t and float(t) > 1e4 else 1), body)
+                       for t, body in _XML_CUE.findall(text)])  # fmt: skip
+    segs, start, buf = [], None, []
+    for line in text.splitlines():
+        if m := _CUE.match(line.strip()):
+            if start is not None and buf:
+                segs.append((start, " ".join(buf)))
+            start, buf = _seconds(m[1]), []
+        elif start is not None and line.strip() and not line.strip().isdigit():
+            buf.append(line.strip())
+        elif not line.strip() and start is not None and buf:
+            segs.append((start, " ".join(buf)))
+            start, buf = None, []
+    if start is not None and buf:
+        segs.append((start, " ".join(buf)))
+    return _clean(segs)
+
+
+def _plain(body: str) -> str:
+    # YouTube timedtext XML double-encodes entities (&amp;#39;), so unescape twice.
+    return " ".join(html.unescape(html.unescape(_INLINE_TAG.sub("", body))).split())
+
+
+def _clean(segs: list[tuple[float, str]]) -> list[tuple[float, str]]:
+    """Strip markup and drop the rolling-caption repeats auto-captions produce."""
+    out: list[tuple[float, str]] = []
+    last = ""
+    for start, body in segs:
+        line = _plain(body)
+        if not line or line == last:
+            continue
+        if last and line.startswith(last):  # rolling cue: keep only the new tail
+            line = line[len(last) :].strip()
+        elif last and last.endswith(line):
+            continue
+        if line:
+            out.append((start, line))
+            last = _plain(body)
+    return out
+
+
+def parse_chapters(description: str) -> list[tuple[float, str]]:
+    chapters = [(_seconds(m[1] + ".000"), m[2]) for ln in description.splitlines()
+                if (m := CHAPTER_LINE.match(ln))]  # fmt: skip
+    return chapters if chapters and chapters[0][0] == 0 else []
+
+
+def to_paragraphs(segs: list[tuple[float, str]], chapters: list[tuple[float, str]] = ()) -> str:
+    out, para, prev_end = [], [], None
+    pending = list(chapters)
+    for start, line in segs:
+        while pending and start >= pending[0][0]:
+            if para:
+                out.append(" ".join(para))
+                para = []
+            out.append(f"## {pending.pop(0)[1]}")
+        gap = prev_end is not None and start - prev_end > GAP_BREAK_S
+        long = sum(len(p) for p in para) > PARAGRAPH_CHARS and _SENTENCE_END.search(para[-1])
+        if para and (gap or long):
+            out.append(" ".join(para))
+            para = []
+        para.append(line)
+        prev_end = start
+    if para:
+        out.append(" ".join(para))
+    return "\n\n".join(out)

agent_wire/models.py

@@ -0,0 +1,60 @@
+"""Strict output schemas. Unknown keys are dropped on validation (outbound firewall layer 3)."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+
+class _Strict(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+
+class WireComment(_Strict):
+    id: str
+    body: str
+    author_handle: str | None = None
+    timestamp: datetime | None = None
+    score: int = 0
+    score_kind: str = "points"  # or "replies" where a site hides comment points (HN)
+    depth: int = 0
+    is_op: bool = False
+    is_accepted: bool = False
+    replies: list["WireComment"] = []
+
+
+class WireDocument(_Strict):
+    url: str
+    channel: str
+    title: str | None = None
+    author_handle: str | None = None
+    timestamp: datetime | None = None
+    score: int | None = None
+    body: str = ""
+    comments: list[WireComment] = []
+    metadata: dict[str, str | int | float | bool | None] = {}
+    # Pipeline telemetry, never rendered into the document text.
+    stage: int = 1
+    auth: str = "none"
+    raw_bytes: int = 0
+
+
+class WireSearchHit(_Strict):
+    url: str
+    title: str
+    snippet: str = ""
+    source: str = "web"
+    rank_score: float = 0.0
+    # Filled where the platform exposes them; wire_research scores freshness and engagement.
+    timestamp: datetime | None = None
+    author: str | None = None
+    link: str | None = None  # the article a post points at (HN/Reddit/Techmeme), for dedup
+    engagement: dict[str, int] = {}  # score, comments, likes, reposts, views, volume ...
+
+
+class WireTelemetry(_Strict):
+    channel: str
+    tokens: int
+    saved_pct: int = 0
+    auth: str = "none"
+    stage: int = 1
+    elapsed_ms: int = 0

agent_wire/research/__init__.py

@@ -0,0 +1 @@
+"""wire_research: last-N-days multi-source research (plan -> collect -> score -> cluster -> brief)."""