multi-agent-registry 0.2.0__tar.gz

multi_agent_registry-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      # https://github.com/actions/checkout
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      # https://github.com/astral-sh/setup-uv
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install
+
+      - name: Run ruff
+        run: uv run ruff check .
+
+      - name: Run pytest
+        run: uv run pytest
+

multi_agent_registry-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,41 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
+jobs:
+  publish:
+    name: Build and publish
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: write
+      attestations: write
+
+    steps:
+      # https://github.com/actions/checkout
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      # https://github.com/astral-sh/setup-uv
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true

multi_agent_registry-0.2.0/.gitignore

@@ -0,0 +1,7 @@
+.venv
+__pycache__/
+*.pyc
+dist/
+*.egg-info/
+.pytest_cache/
+.ruff_cache/

multi_agent_registry-0.2.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.5
+Name: multi-agent-registry
+Version: 0.2.0
+Summary: Unified detection, configuration, and chat discovery registry for AI coding agent CLIs
+Author-email: Mark Stouffer <1802850+InTEGr8or@users.noreply.github.com>
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: verkit>=0.1.4
+Description-Content-Type: text/markdown
+
+# Multi-Agent Registry 🤖
+
+Unified detection, configuration, plugin, and chat history discovery registry for AI coding agent CLIs.
+
+`multi_agent_registry` gives any tool a single place to ask "which AI coding agents are installed on this machine, where do they keep their config/plugins, and where did they leave their chat history?" — instead of every consumer re-implementing per-agent path guessing.
+
+---
+
+## Installation
+
+```bash
+pip install multi-agent-registry
+# or using uv
+uv add multi-agent-registry
+```
+
+The PyPI **distribution** name is `multi-agent-registry`; the importable **module** name is `multi_agent_registry`:
+
+```python
+import multi_agent_registry
+```
+
+## Features
+
+- **Multi-Agent CLI Detection**: A registry of 15 agent CLIs — Claude Code, Antigravity (`agy`), OpenCode, GitHub Copilot, Grok Build, Cursor, Windsurf, Aider, Codex, Continue, Cline, Roo Code, Goose, ShellGPT, and Open Interpreter — with binary name, description, and config paths for each.
+- **Installation & MCP Inspection**: `inspect_agent_cli()`/`inspect_all_agent_clis()` check whether each agent's binary is on `PATH`, whether it's registered as an MCP server, and whether a plugin is installed for it.
+- **Chat Log Discovery**: `discover_agent_chats()` scans the on-disk chat log locations for agents that expose them (currently Claude Code, Antigravity, OpenCode, Aider, Cline, and Roo Code), with recursive-glob patterns pruned to skip `node_modules`/`.venv`/`.git`/`.gwt` for speed.
+- **Chat Inspection Helpers**: `get_chat_workspace()` and `get_chat_last_active()` read each agent's own on-disk format to resolve which project a chat belongs to and when it was truly last active (not just file mtime).
+- **Plugin Enable/Disable State**: Per-agent plugin opt-out, persisted to `~/.config/task-agent/config.json`, for tools that install agent-specific plugins/skills.
+
+## Quickstart
+
+```python
+from multi_agent_registry import get_agent_cli_registry, discover_agent_chats, get_chat_workspace
+
+# What agents does this machine have?
+for agent_id, info in get_agent_cli_registry().items():
+    print(agent_id, info.name, info.binary)
+
+# Where has Claude Code been chatting, and about which projects?
+for chat in discover_agent_chats(agent_id="claude"):
+    workspace = get_chat_workspace(chat)
+    print(chat.path, "->", workspace)
+```
+
+## API Reference
+
+### Registry & detection
+
+```python
+from multi_agent_registry import AgentCLIInfo, get_agent_cli_registry, inspect_agent_cli, inspect_all_agent_clis
+
+registry: dict[str, AgentCLIInfo] = get_agent_cli_registry()
+info = registry["claude"]
+info.id, info.name, info.binary, info.description
+info.config_paths        # list[Path] of possible config file locations
+info.mcp_support, info.mcp_command_example
+info.plugin_support, info.plugin_path, info.skills_path, info.plugin_template
+info.chat_log_patterns   # list[str] glob patterns, [] if not yet supported
+info.chat_parser_type    # "json" | "jsonl" | "markdown"
+
+status = inspect_agent_cli("claude")   # dict: installed, mcp_registered, plugin_installed, ...
+all_status = inspect_all_agent_clis()  # same, for every registered agent
+```
+
+### Chat discovery
+
+```python
+from multi_agent_registry import DiscoveredChat, discover_agent_chats
+from pathlib import Path
+
+# All chats for one agent, scanned globally (patterns rooted at ~ or /)
+# or within specific project roots (patterns relative to a project).
+chats: list[DiscoveredChat] = discover_agent_chats(
+    agent_id="aider",                                   # omit to scan every agent
+    search_roots=[Path.home() / "repos"],                # only used for project-relative patterns
+)
+# chat.agent_id, chat.path, chat.parser_type
+```
+
+Agents currently wired up for chat discovery: `claude`, `agy` (Antigravity), `opencode`, `aider`, `cline`, `roo`. The rest are registered for detection/config/plugin purposes but don't yet have `chat_log_patterns` populated — contributions welcome.
+
+### Chat inspection
+
+```python
+from multi_agent_registry import get_chat_workspace, get_chat_last_active
+
+get_chat_workspace(chat)     # -> Path | None, the project dir the chat belongs to
+get_chat_last_active(chat)   # -> datetime | None, true last-message time (jsonl only for now);
+                              #    callers should fall back to file mtime when None
+```
+
+## Notes for tools built on this library
+
+- Absolute/home-relative `chat_log_patterns` (e.g. `~/.claude/projects/**/*.jsonl`) are scanned once, globally — `search_roots`/`project_dir` only affects patterns relative to a project (e.g. Aider's `**/.aider.chat.history.md`).
+- `discover_agent_chats()` shells out to `find` for bare recursive-filename patterns (pruning noise directories natively) rather than `glob.glob(recursive=True)`, which must fully traverse a tree before filtering — orders of magnitude faster on large repo trees.
+- `get_chat_workspace()`/`get_chat_last_active()` read each agent's actual on-disk message format (e.g. scanning forward past Claude Code's leading metadata-only jsonl lines for the first `cwd`/`timestamp`) rather than assuming a fixed line/file layout.

multi_agent_registry-0.2.0/README.md

@@ -0,0 +1,97 @@
+# Multi-Agent Registry 🤖
+
+Unified detection, configuration, plugin, and chat history discovery registry for AI coding agent CLIs.
+
+`multi_agent_registry` gives any tool a single place to ask "which AI coding agents are installed on this machine, where do they keep their config/plugins, and where did they leave their chat history?" — instead of every consumer re-implementing per-agent path guessing.
+
+---
+
+## Installation
+
+```bash
+pip install multi-agent-registry
+# or using uv
+uv add multi-agent-registry
+```
+
+The PyPI **distribution** name is `multi-agent-registry`; the importable **module** name is `multi_agent_registry`:
+
+```python
+import multi_agent_registry
+```
+
+## Features
+
+- **Multi-Agent CLI Detection**: A registry of 15 agent CLIs — Claude Code, Antigravity (`agy`), OpenCode, GitHub Copilot, Grok Build, Cursor, Windsurf, Aider, Codex, Continue, Cline, Roo Code, Goose, ShellGPT, and Open Interpreter — with binary name, description, and config paths for each.
+- **Installation & MCP Inspection**: `inspect_agent_cli()`/`inspect_all_agent_clis()` check whether each agent's binary is on `PATH`, whether it's registered as an MCP server, and whether a plugin is installed for it.
+- **Chat Log Discovery**: `discover_agent_chats()` scans the on-disk chat log locations for agents that expose them (currently Claude Code, Antigravity, OpenCode, Aider, Cline, and Roo Code), with recursive-glob patterns pruned to skip `node_modules`/`.venv`/`.git`/`.gwt` for speed.
+- **Chat Inspection Helpers**: `get_chat_workspace()` and `get_chat_last_active()` read each agent's own on-disk format to resolve which project a chat belongs to and when it was truly last active (not just file mtime).
+- **Plugin Enable/Disable State**: Per-agent plugin opt-out, persisted to `~/.config/task-agent/config.json`, for tools that install agent-specific plugins/skills.
+
+## Quickstart
+
+```python
+from multi_agent_registry import get_agent_cli_registry, discover_agent_chats, get_chat_workspace
+
+# What agents does this machine have?
+for agent_id, info in get_agent_cli_registry().items():
+    print(agent_id, info.name, info.binary)
+
+# Where has Claude Code been chatting, and about which projects?
+for chat in discover_agent_chats(agent_id="claude"):
+    workspace = get_chat_workspace(chat)
+    print(chat.path, "->", workspace)
+```
+
+## API Reference
+
+### Registry & detection
+
+```python
+from multi_agent_registry import AgentCLIInfo, get_agent_cli_registry, inspect_agent_cli, inspect_all_agent_clis
+
+registry: dict[str, AgentCLIInfo] = get_agent_cli_registry()
+info = registry["claude"]
+info.id, info.name, info.binary, info.description
+info.config_paths        # list[Path] of possible config file locations
+info.mcp_support, info.mcp_command_example
+info.plugin_support, info.plugin_path, info.skills_path, info.plugin_template
+info.chat_log_patterns   # list[str] glob patterns, [] if not yet supported
+info.chat_parser_type    # "json" | "jsonl" | "markdown"
+
+status = inspect_agent_cli("claude")   # dict: installed, mcp_registered, plugin_installed, ...
+all_status = inspect_all_agent_clis()  # same, for every registered agent
+```
+
+### Chat discovery
+
+```python
+from multi_agent_registry import DiscoveredChat, discover_agent_chats
+from pathlib import Path
+
+# All chats for one agent, scanned globally (patterns rooted at ~ or /)
+# or within specific project roots (patterns relative to a project).
+chats: list[DiscoveredChat] = discover_agent_chats(
+    agent_id="aider",                                   # omit to scan every agent
+    search_roots=[Path.home() / "repos"],                # only used for project-relative patterns
+)
+# chat.agent_id, chat.path, chat.parser_type
+```
+
+Agents currently wired up for chat discovery: `claude`, `agy` (Antigravity), `opencode`, `aider`, `cline`, `roo`. The rest are registered for detection/config/plugin purposes but don't yet have `chat_log_patterns` populated — contributions welcome.
+
+### Chat inspection
+
+```python
+from multi_agent_registry import get_chat_workspace, get_chat_last_active
+
+get_chat_workspace(chat)     # -> Path | None, the project dir the chat belongs to
+get_chat_last_active(chat)   # -> datetime | None, true last-message time (jsonl only for now);
+                              #    callers should fall back to file mtime when None
+```
+
+## Notes for tools built on this library
+
+- Absolute/home-relative `chat_log_patterns` (e.g. `~/.claude/projects/**/*.jsonl`) are scanned once, globally — `search_roots`/`project_dir` only affects patterns relative to a project (e.g. Aider's `**/.aider.chat.history.md`).
+- `discover_agent_chats()` shells out to `find` for bare recursive-filename patterns (pruning noise directories natively) rather than `glob.glob(recursive=True)`, which must fully traverse a tree before filtering — orders of magnitude faster on large repo trees.
+- `get_chat_workspace()`/`get_chat_last_active()` read each agent's actual on-disk message format (e.g. scanning forward past Claude Code's leading metadata-only jsonl lines for the first `cwd`/`timestamp`) rather than assuming a fixed line/file layout.

multi_agent_registry-0.2.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "multi-agent-registry"
+version = "0.2.0"
+description = "Unified detection, configuration, and chat discovery registry for AI coding agent CLIs"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "Mark Stouffer", email = "1802850+InTEGr8or@users.noreply.github.com" }
+]
+dependencies = [
+    "verkit>=0.1.4",
+]
+
+[tool.hatch.build]
+exclude = [
+    "docs/",
+    ".task-agent/",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/multi_agent_registry"]
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

multi_agent_registry-0.2.0/src/multi_agent_registry/__init__.py

@@ -0,0 +1,25 @@
+"""Agent Registry package initialization."""
+
+from multi_agent_registry.discovery import (
+    DiscoveredChat,
+    discover_agent_chats,
+    get_chat_last_active,
+    get_chat_workspace,
+)
+from multi_agent_registry.registry import (
+    AgentCLIInfo,
+    get_agent_cli_registry,
+    inspect_agent_cli,
+    inspect_all_agent_clis,
+)
+
+__all__ = [
+    "AgentCLIInfo",
+    "DiscoveredChat",
+    "get_agent_cli_registry",
+    "inspect_agent_cli",
+    "inspect_all_agent_clis",
+    "discover_agent_chats",
+    "get_chat_workspace",
+    "get_chat_last_active",
+]

multi_agent_registry-0.2.0/src/multi_agent_registry/discovery.py

@@ -0,0 +1,232 @@
+"""Discovery module for scanning agent chat log files."""
+
+from dataclasses import dataclass
+from datetime import datetime
+import fnmatch
+import glob
+import json
+import os
+import re
+import subprocess
+from pathlib import Path
+from typing import List, Optional
+
+from multi_agent_registry.registry import AgentCLIInfo, get_agent_cli_registry
+
+EXCLUDED_DIR_NAMES = {"node_modules", ".venv", ".git", ".gwt"}
+
+
+def _resolve_host_root(project_dir: Path) -> Path:
+    """Resolve project directory host root, unwrapping .gwt/<slug> worktrees if present."""
+    try:
+        from taskagent.store_registry import project_host_root
+
+        return project_host_root(project_dir)
+    except ImportError:
+        resolved = project_dir.resolve()
+        if ".gwt" in resolved.parts:
+            try:
+                idx = list(resolved.parts).index(".gwt")
+                return Path(*resolved.parts[:idx])
+            except ValueError:
+                pass
+        return resolved
+
+
+@dataclass
+class DiscoveredChat:
+    """Represents a discovered agent chat log file."""
+
+    agent_id: str
+    path: Path
+    parser_type: str
+
+
+def _is_excluded(path: Path) -> bool:
+    return any(part in EXCLUDED_DIR_NAMES for part in path.parts)
+
+
+def _find_recursive(host_root: Path, filename: str) -> List[str]:
+    prune_expr = []
+    for name in EXCLUDED_DIR_NAMES:
+        if prune_expr:
+            prune_expr.append("-o")
+        prune_expr += ["-name", name]
+
+    cmd = (
+        ["find", str(host_root), "("] + prune_expr + [")", "-prune", "-o"]
+        + ["-type", "f", "-name", filename, "-print"]
+    )
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        return [line for line in result.stdout.splitlines() if line.strip()]
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        matched = []
+        for root, dirnames, filenames in os.walk(host_root):
+            dirnames[:] = [d for d in dirnames if d not in EXCLUDED_DIR_NAMES]
+            for name in filenames:
+                if fnmatch.fnmatch(name, filename):
+                    matched.append(os.path.join(root, name))
+        return matched
+
+
+def _expand_pattern(pattern: str, host_root: Path) -> List[Path]:
+    if pattern.startswith("~"):
+        expanded = str(Path(pattern).expanduser())
+        matched = glob.glob(expanded, recursive=True)
+    elif pattern.startswith("/"):
+        matched = glob.glob(pattern, recursive=True)
+    else:
+        if not host_root.exists():
+            return []
+        if pattern.startswith("**/") and "/" not in pattern[3:]:
+            # A bare recursive filename match (e.g. Aider's
+            # "**/.aider.chat.history.md"). glob.glob(recursive=True) must
+            # fully traverse every directory -- including huge
+            # node_modules/.venv trees -- before results can be filtered
+            # out, and even a pruning os.walk is too slow in pure Python
+            # over large repo trees (seconds -> minutes). Shell out to
+            # `find`, which prunes natively and is ~1000x faster in
+            # practice; fall back to a pruning walk if `find` is missing.
+            filename = pattern[3:]
+            matched = _find_recursive(host_root, filename)
+        else:
+            joined = str(host_root / pattern)
+            matched = glob.glob(joined, recursive=True)
+
+    results: List[Path] = []
+    for match in matched:
+        p = Path(match)
+        if p.is_file() and not _is_excluded(p):
+            results.append(p)
+    return results
+
+
+def discover_agent_chats(
+    agent_id: Optional[str] = None,
+    project_dir: Optional[Path] = None,
+    search_roots: Optional[List[Path]] = None,
+) -> List[DiscoveredChat]:
+    """Discover chat log files for one or all registered agent CLIs.
+
+    Absolute/home-relative patterns (e.g. ``~/.claude/projects/**/*.jsonl``)
+    are scanned once, independent of any root. Patterns relative to a
+    project (e.g. Aider's ``**/.aider.chat.history.md``) are joined against
+    each of ``search_roots`` when given, or a single resolved
+    ``project_dir``/cwd otherwise. Recursive scans skip noise directories
+    (``node_modules``, ``.venv``, ``.git``, ``.gwt``).
+    """
+    registry = get_agent_cli_registry()
+
+    if agent_id is not None:
+        if agent_id not in registry:
+            raise ValueError(f"Unknown agent CLI: '{agent_id}'")
+        agents_to_scan: List[AgentCLIInfo] = [registry[agent_id]]
+    else:
+        agents_to_scan = list(registry.values())
+
+    if search_roots:
+        host_roots = [_resolve_host_root(r) for r in search_roots]
+    else:
+        if project_dir is None:
+            project_dir = Path.cwd()
+        host_roots = [_resolve_host_root(project_dir)]
+
+    discovered: List[DiscoveredChat] = []
+    seen_paths = set()
+
+    for agent in agents_to_scan:
+        if not agent.chat_log_patterns:
+            continue
+
+        for pattern in agent.chat_log_patterns:
+            is_rooted = pattern.startswith("~") or pattern.startswith("/")
+            roots_to_try = [host_roots[0]] if is_rooted else host_roots
+
+            for host_root in roots_to_try:
+                found_paths = _expand_pattern(pattern, host_root)
+                for path in found_paths:
+                    resolved = path.resolve()
+                    if resolved not in seen_paths:
+                        seen_paths.add(resolved)
+                        discovered.append(
+                            DiscoveredChat(
+                                agent_id=agent.id,
+                                path=path,
+                                parser_type=agent.chat_parser_type,
+                            )
+                        )
+
+    discovered.sort(key=lambda item: item.path)
+    return discovered
+
+
+def get_chat_workspace(chat: DiscoveredChat) -> Optional[Path]:
+    """Best-effort resolution of which project/repo a discovered chat belongs to.
+
+    Reads the on-disk structure each agent uses to record its working
+    directory, rather than relying on the chat file's own location.
+    """
+    try:
+        if chat.parser_type == "jsonl":
+            # Leading lines are often session metadata (mode, snapshots) with
+            # no `cwd` field; scan forward (capped) for the first one that
+            # has it rather than assuming line 1.
+            with open(chat.path, "r") as f:
+                for _, line in zip(range(200), f):
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        data = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    cwd = data.get("cwd")
+                    if cwd:
+                        return Path(cwd)
+        elif chat.parser_type == "markdown":
+            return chat.path.parent
+        elif chat.parser_type == "json":
+            with open(chat.path, "r") as f:
+                content = f.read(10000)
+            match = re.search(r"Current Workspace Directory \((.*?)\)", content)
+            if match:
+                return Path(match.group(1))
+    except Exception:
+        pass
+    return None
+
+
+def get_chat_last_active(chat: DiscoveredChat) -> Optional[datetime]:
+    """Best-effort true last-active timestamp for a chat log.
+
+    Scans per-message timestamps rather than trusting file mtime, which can
+    be misleading (e.g. a metadata-only stub rewritten without new
+    messages). Returns None when the format isn't understood yet, in which
+    case callers should fall back to file mtime.
+    """
+    try:
+        if chat.parser_type == "jsonl":
+            last_ts = None
+            with open(chat.path, "r") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        data = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    ts = data.get("timestamp")
+                    if not ts:
+                        continue
+                    try:
+                        parsed = datetime.fromisoformat(ts.replace("Z", "+00:00"))
+                    except ValueError:
+                        continue
+                    if last_ts is None or parsed > last_ts:
+                        last_ts = parsed
+            return last_ts
+    except Exception:
+        pass
+    return None

multi_agent_registry-0.2.0/src/multi_agent_registry/models.py

@@ -0,0 +1,31 @@
+"""Data models for agent CLI registry and discovery."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+
+@dataclass
+class AgentCLIInfo:
+    id: str
+    name: str
+    binary: str
+    description: str
+    config_paths: List[Path] = field(default_factory=list)
+    mcp_support: bool = True
+    mcp_command_example: str = ""
+    plugin_support: bool = False
+    plugin_path: Optional[Path] = None
+    skills_path: Optional[Path] = None
+    plugin_template: str = ""
+    chat_log_patterns: List[str] = field(default_factory=list)
+    chat_parser_type: str = "json"
+
+
+@dataclass
+class DiscoveredChat:
+    """Represents a discovered agent chat log file."""
+
+    agent_id: str
+    path: Path
+    parser_type: str

multi_agent_registry-0.2.0/src/multi_agent_registry/registry.py

@@ -0,0 +1,340 @@
+"""Agent CLI Detection Registry for Task Agent.
+
+Provides a unified registry of popular agent CLIs, detection logic, global/project
+MCP configuration paths, and plugin installation helpers.
+"""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import shutil
+from typing import Dict, List, Optional
+
+
+@dataclass
+class AgentCLIInfo:
+    id: str
+    name: str
+    binary: str
+    description: str
+    config_paths: List[Path] = field(default_factory=list)
+    mcp_support: bool = True
+    mcp_command_example: str = ""
+    plugin_support: bool = False
+    plugin_path: Optional[Path] = None
+    skills_path: Optional[Path] = None
+    plugin_template: str = ""
+    chat_log_patterns: List[str] = field(default_factory=list)
+    chat_parser_type: str = "json"
+
+
+def get_agent_cli_registry() -> Dict[str, AgentCLIInfo]:
+    home = Path.home()
+    return {
+        "claude": AgentCLIInfo(
+            id="claude",
+            name="Claude Code",
+            binary="claude",
+            description="Anthropic's agentic coding CLI tool",
+            config_paths=[home / ".claude.json", home / ".claude" / "config.json"],
+            mcp_support=True,
+            mcp_command_example="ta init-mcp --claude",
+            plugin_support=True,
+            plugin_path=home / ".claude" / "plugins",
+            skills_path=home / ".claude" / "commands",
+            plugin_template="claude-code",
+            chat_log_patterns=[
+                "~/.claude/projects/**/*.jsonl",
+                "~/.claude/history.jsonl",
+            ],
+            chat_parser_type="jsonl",
+        ),
+        "agy": AgentCLIInfo(
+            id="agy",
+            name="Antigravity CLI",
+            binary="agy",
+            description="Google DeepMind Antigravity CLI",
+            config_paths=[home / ".gemini" / "antigravity-cli" / "mcp_config.json"],
+            mcp_support=True,
+            mcp_command_example="ta init-mcp --agy",
+            plugin_support=True,
+            plugin_path=home / ".gemini" / "antigravity-cli" / "plugins",
+            skills_path=home / ".gemini" / "config" / "skills",
+            plugin_template="antigravity",
+            chat_log_patterns=[
+                "~/.gemini/tmp/**/chats/session-*.json",
+                "~/.gemini/antigravity-cli/brain/**/transcript.jsonl",
+                "~/.gemini/antigravity-cli/brain/**/transcript_full.jsonl",
+            ],
+            chat_parser_type="json",
+        ),
+        "opencode": AgentCLIInfo(
+            id="opencode",
+            name="OpenCode",
+            binary="opencode",
+            description="Open-source agentic coding workspace and TUI",
+            config_paths=[home / ".config" / "opencode" / "opencode.json"],
+            mcp_support=True,
+            mcp_command_example="ta init-mcp --opencode",
+            plugin_support=True,
+            plugin_path=home / ".config" / "opencode" / "plugins",
+            skills_path=home / ".config" / "opencode" / "skills",
+            plugin_template="opencode",
+            chat_log_patterns=[
+                "~/.local/share/opencode/storage/**/*.json",
+                "~/.local/share/opencode/sessions/*.json",
+                "~/.config/opencode/chats/*.json",
+            ],
+            chat_parser_type="json",
+        ),
+        "copilot": AgentCLIInfo(
+            id="copilot",
+            name="GitHub Copilot CLI",
+            binary="copilot",
+            description="GitHub Copilot CLI agent",
+            config_paths=[home / ".config" / "github-copilot" / "config.json"],
+            mcp_support=True,
+            mcp_command_example="ta init-mcp --copilot",
+            plugin_support=True,
+            plugin_path=home / ".config" / "github-copilot" / "plugins",
+            skills_path=home / ".config" / "github-copilot" / "skills",
+            plugin_template="copilot",
+        ),
+        "grok": AgentCLIInfo(
+            id="grok",
+            name="Grok Build",
+            binary="grok",
+            description="xAI Grok coding assistant CLI",
+            config_paths=[home / ".config" / "grok" / "config.json"],
+            mcp_support=True,
+            mcp_command_example="ta init-mcp --agent grok",
+            plugin_support=True,
+            plugin_path=home / ".config" / "grok" / "plugins",
+            skills_path=home / ".config" / "grok" / "skills",
+            plugin_template="grok",
+        ),
+        "cursor": AgentCLIInfo(
+            id="cursor",
+            name="Cursor CLI",
+            binary="cursor",
+            description="Cursor AI editor CLI interface",
+            config_paths=[
+                home / ".cursor" / "mcp.json",
+                home / ".config" / "Cursor" / "mcp.json",
+            ],
+            mcp_support=True,
+            mcp_command_example="ta init-mcp --print",
+            plugin_support=True,
+            plugin_path=home / ".cursor" / "plugins",
+            skills_path=home / ".cursor" / "skills",
+            plugin_template="cursor",
+        ),
+        "windsurf": AgentCLIInfo(
+            id="windsurf",
+            name="Windsurf",
+            binary="windsurf",
+            description="Codeium Windsurf AI IDE CLI",
+            config_paths=[home / ".codeium" / "windsurf" / "mcp_config.json"],
+            mcp_support=True,
+            mcp_command_example="ta init-mcp --print",
+            plugin_support=True,
+            plugin_path=home / ".codeium" / "windsurf" / "plugins",
+            skills_path=home / ".codeium" / "windsurf" / "skills",
+            plugin_template="windsurf",
+        ),
+        "aider": AgentCLIInfo(
+            id="aider",
+            name="Aider",
+            binary="aider",
+            description="AI pair programming in your terminal",
+            config_paths=[home / ".aider.conf.yml"],
+            mcp_support=False,
+            plugin_support=False,
+            chat_log_patterns=[
+                "**/.aider.chat.history.md",
+                "~/.aider.chat.history.md",
+            ],
+            chat_parser_type="markdown",
+        ),
+        "codex": AgentCLIInfo(
+            id="codex",
+            name="Codex CLI / ADK Worker",
+            binary="codex",
+            description="OpenAI Codex CLI harness",
+            config_paths=[home / ".codex" / "config.json"],
+            mcp_support=True,
+            plugin_support=True,
+            plugin_path=home / ".codex" / "plugins",
+            skills_path=home / ".codex" / "skills",
+            plugin_template="codex",
+        ),
+        "continue": AgentCLIInfo(
+            id="continue",
+            name="Continue",
+            binary="continue",
+            description="Open-source AI code assistant",
+            config_paths=[home / ".continue" / "config.json"],
+            mcp_support=True,
+            plugin_support=True,
+            plugin_path=home / ".continue" / "plugins",
+            skills_path=home / ".continue" / "skills",
+            plugin_template="continue",
+        ),
+        "cline": AgentCLIInfo(
+            id="cline",
+            name="Cline",
+            binary="cline",
+            description="Autonomous coding agent extension & CLI",
+            config_paths=[home / ".cline" / "mcp_settings.json"],
+            mcp_support=True,
+            plugin_support=True,
+            chat_log_patterns=[
+                "~/.vscode-server/data/User/globalStorage/saoudrizwan.claude-dev/tasks/*/ui_messages.json",
+                "~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/tasks/*/ui_messages.json",
+            ],
+            chat_parser_type="json",
+        ),
+        "roo": AgentCLIInfo(
+            id="roo",
+            name="Roo Code",
+            binary="roo",
+            description="Roo Code AI coding assistant",
+            config_paths=[home / ".roo" / "mcp_settings.json"],
+            mcp_support=True,
+            plugin_support=True,
+            chat_log_patterns=[
+                "~/.vscode-server/data/User/globalStorage/rooveterinaryinc.roo-cline/tasks/*/ui_messages.json",
+                "~/.vscode-server-insiders/data/User/globalStorage/rooveterinaryinc.roo-cline/tasks/*/ui_messages.json",
+                "~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/tasks/*/ui_messages.json",
+                "~/.config/Code - Insiders/User/globalStorage/rooveterinaryinc.roo-cline/tasks/*/ui_messages.json",
+            ],
+            chat_parser_type="json",
+        ),
+        "goose": AgentCLIInfo(
+            id="goose",
+            name="Goose",
+            binary="goose",
+            description="Block's open-source AI agent framework",
+            config_paths=[home / ".config" / "goose" / "config.yaml"],
+            mcp_support=True,
+            plugin_support=False,
+        ),
+        "sgpt": AgentCLIInfo(
+            id="sgpt",
+            name="ShellGPT",
+            binary="sgpt",
+            description="Command-line productivity tool powered by AI",
+            config_paths=[home / ".config" / "shell_gpt" / ".sgptrc"],
+            mcp_support=False,
+            plugin_support=False,
+        ),
+        "interpreter": AgentCLIInfo(
+            id="interpreter",
+            name="Open Interpreter",
+            binary="interpreter",
+            description="Natural language interface to computer capabilities",
+            config_paths=[home / ".config" / "open-interpreter" / "config.yaml"],
+            mcp_support=False,
+            plugin_support=False,
+        ),
+    }
+
+
+def inspect_agent_cli(agent_id: str) -> dict:
+    """Inspect local installation and MCP registration status for an agent CLI."""
+    registry = get_agent_cli_registry()
+    if agent_id not in registry:
+        raise ValueError(f"Unknown agent CLI: '{agent_id}'")
+
+    info = registry[agent_id]
+    installed = shutil.which(info.binary) is not None
+    mcp_registered = False
+
+    for config_path in info.config_paths:
+        if config_path.is_file():
+            try:
+                content = config_path.read_text(encoding="utf-8")
+                if "task_agent" in content or "task-agent" in content:
+                    mcp_registered = True
+                    break
+            except Exception:
+                pass
+
+    plugin_installed = False
+    if info.plugin_path and info.plugin_path.exists():
+        try:
+            if any("task-agent" in p.name for p in info.plugin_path.iterdir()):
+                plugin_installed = True
+        except Exception:
+            pass
+
+    return {
+        "id": info.id,
+        "name": info.name,
+        "binary": info.binary,
+        "description": info.description,
+        "installed": installed,
+        "mcp_support": info.mcp_support,
+        "mcp_registered": mcp_registered,
+        "plugin_support": info.plugin_support,
+        "plugin_installed": plugin_installed,
+        "mcp_command_example": info.mcp_command_example,
+        "chat_log_patterns": info.chat_log_patterns,
+        "chat_parser_type": info.chat_parser_type,
+    }
+
+
+def inspect_all_agent_clis() -> List[dict]:
+    """Inspect local installation status for all registered agent CLIs."""
+    registry = get_agent_cli_registry()
+    return [inspect_agent_cli(agent_id) for agent_id in registry]
+
+
+def get_disabled_agent_plugins() -> List[str]:
+    """Load list of explicitly disabled agent plugins from task-agent user config."""
+    import json
+
+    config_file = Path.home() / ".config" / "task-agent" / "config.json"
+    if config_file.is_file():
+        try:
+            data = json.loads(config_file.read_text(encoding="utf-8"))
+            disabled = data.get("plugins", {}).get("disabled_agents", [])
+            if isinstance(disabled, list):
+                return [str(item) for item in disabled]
+        except Exception:
+            pass
+    return []
+
+
+def set_agent_plugin_enabled(agent_id: str, enabled: bool) -> None:
+    """Enable or disable a specific agent plugin in task-agent user config."""
+    import json
+
+    config_dir = Path.home() / ".config" / "task-agent"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_file = config_dir / "config.json"
+
+    data: dict = {}
+    if config_file.is_file():
+        try:
+            data = json.loads(config_file.read_text(encoding="utf-8"))
+        except Exception:
+            data = {}
+
+    plugins_cfg = data.setdefault("plugins", {})
+    disabled = plugins_cfg.setdefault("disabled_agents", [])
+
+    if enabled and agent_id in disabled:
+        disabled.remove(agent_id)
+    elif not enabled and agent_id not in disabled:
+        disabled.append(agent_id)
+
+    config_file.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+
+def is_agent_plugin_enabled(
+    agent_id: str, disabled_list: Optional[List[str]] = None
+) -> bool:
+    """Check if an agent plugin is enabled (enabled by default unless explicitly disabled)."""
+    if disabled_list is None:
+        disabled_list = get_disabled_agent_plugins()
+    return agent_id not in disabled_list

multi_agent_registry-0.2.0/tests/test_registry.py

@@ -0,0 +1,105 @@
+"""Tests for agent chat log pattern registration and discovery."""
+
+from pathlib import Path
+
+import pytest
+
+from multi_agent_registry import (
+    AgentCLIInfo,
+    DiscoveredChat,
+    discover_agent_chats,
+    get_agent_cli_registry,
+    inspect_agent_cli,
+)
+
+
+def test_agent_cli_registry_has_chat_log_patterns():
+    registry = get_agent_cli_registry()
+
+    expected_agents = ["agy", "roo", "cline", "aider", "claude", "opencode"]
+    for agent_id in expected_agents:
+        assert agent_id in registry
+        info = registry[agent_id]
+        assert isinstance(info.chat_log_patterns, list)
+        assert len(info.chat_log_patterns) > 0
+        assert isinstance(info.chat_parser_type, str)
+        assert len(info.chat_parser_type) > 0
+
+    assert registry["claude"].chat_parser_type == "jsonl"
+    assert registry["aider"].chat_parser_type == "markdown"
+    assert registry["agy"].chat_parser_type == "json"
+
+
+def test_agent_cli_info_defaults():
+    info = AgentCLIInfo(
+        id="test",
+        name="Test Agent",
+        binary="test",
+        description="Test description",
+    )
+    assert info.chat_log_patterns == []
+    assert info.chat_parser_type == "json"
+
+
+def test_inspect_agent_cli_chat_info():
+    info = inspect_agent_cli("claude")
+    assert "chat_log_patterns" in info
+    assert "chat_parser_type" in info
+    assert info["chat_parser_type"] == "jsonl"
+    assert len(info["chat_log_patterns"]) > 0
+
+
+def test_discover_agent_chats_unknown_agent():
+    with pytest.raises(ValueError, match="Unknown agent CLI"):
+        discover_agent_chats("nonexistent_agent_xyz")
+
+
+def test_discover_agent_chats_all_agents():
+    chats = discover_agent_chats()
+    assert isinstance(chats, list)
+    for chat in chats:
+        assert isinstance(chat, DiscoveredChat)
+        assert isinstance(chat.agent_id, str)
+        assert isinstance(chat.path, Path)
+        assert isinstance(chat.parser_type, str)
+
+
+def test_discover_agent_chats_specific_agent():
+    chats = discover_agent_chats("claude")
+    assert isinstance(chats, list)
+    for chat in chats:
+        assert chat.agent_id == "claude"
+        assert chat.parser_type == "jsonl"
+
+
+def test_discover_agent_chats_repo_scoping_with_gwt(tmp_path: Path):
+    host_root = tmp_path / "my_project"
+    host_root.mkdir()
+    gwt_dir = host_root / ".gwt" / "feature-branch"
+    gwt_dir.mkdir(parents=True)
+
+    history_file = host_root / ".aider.chat.history.md"
+    history_file.write_text("# Aider Chat History\n", encoding="utf-8")
+
+    chats = discover_agent_chats("aider", project_dir=gwt_dir)
+    found_paths = [chat.path.resolve() for chat in chats]
+    assert history_file.resolve() in found_paths
+
+
+def test_discover_agent_chats_home_expansion(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    fake_home = tmp_path / "home"
+    fake_home.mkdir()
+    monkeypatch.setenv("HOME", str(fake_home))
+    monkeypatch.setattr("pathlib.Path.home", lambda: fake_home)
+
+    claude_project_dir = fake_home / ".claude" / "projects" / "my-repo"
+    claude_project_dir.mkdir(parents=True)
+    chat_file = claude_project_dir / "session.jsonl"
+    chat_file.write_text('{"role": "user", "content": "hello"}\n', encoding="utf-8")
+
+    chats = discover_agent_chats("claude", project_dir=tmp_path)
+    found_chats = [c for c in chats if c.agent_id == "claude"]
+    assert len(found_chats) > 0
+    assert any(c.path.resolve() == chat_file.resolve() for c in found_chats)
+    matched = [c for c in found_chats if c.path.resolve() == chat_file.resolve()][0]
+    assert matched.parser_type == "jsonl"

multi_agent_registry-0.2.0/uv.lock

@@ -0,0 +1,69 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "markdown-it-py"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "multi-agent-registry"
+version = "0.2.0"
+source = { editable = "." }
+dependencies = [
+    { name = "verkit" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "verkit", specifier = ">=0.1.4" }]
+
+[[package]]
+name = "pygments"
+version = "2.21.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" },
+]
+
+[[package]]
+name = "rich"
+version = "15.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
+]
+
+[[package]]
+name = "verkit"
+version = "0.1.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "rich" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a8/68/70d0727c0feff38a35881f0db362c93ebdf6dc4b14b024b3b4434f1795de/verkit-0.1.4.tar.gz", hash = "sha256:2ec6bf18124736783517c16858ac3799a21ba89e4fcc324a3ad22930c0b52cc8", size = 9034, upload-time = "2026-07-31T14:56:38.01Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/ee/6eadd91f262d01b316722e768b549248b1a660ac20029b67bc2dc2e97bf0/verkit-0.1.4-py3-none-any.whl", hash = "sha256:bce42636d1bfb22e20e63bfccf74df8349836c17930ef1c3d3bd836e7a170cbb", size = 9149, upload-time = "2026-07-31T14:56:36.889Z" },
+]