conduct-cli 0.4.28__tar.gz → 0.4.30__tar.gz

{conduct_cli-0.4.28 → conduct_cli-0.4.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.4.28
+Version: 0.4.30
 Summary: CLI for Conduct AI — install agents, manage projects, run tests
 Author-email: Conduct AI <hello@conductai.ai>
 License: MIT

{conduct_cli-0.4.28 → conduct_cli-0.4.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "conduct-cli"
-version = "0.4.28"
+version = "0.4.30"
 description = "CLI for Conduct AI — install agents, manage projects, run tests"
 readme = "README.md"
 license = { text = "MIT" }

{conduct_cli-0.4.28 → conduct_cli-0.4.30}/src/conduct_cli/guard.py

@@ -832,6 +832,124 @@ def cmd_guard_join(args):
     )
 
 
+def _report_tools_to_server() -> None:
+    """Detect AI coding tools on this machine and POST coverage to Guard API. Silent on failure."""
+    home = Path.home()
+
+    def _check_json_key(path: Path, *keys) -> bool:
+        try:
+            d = json.loads(path.read_text()) if path.exists() else {}
+            for k in keys:
+                d = d.get(k, {}) if isinstance(d, dict) else {}
+            return bool(d) and isinstance(d, dict) and len(d) > 0
+        except Exception:
+            return False
+
+    def _check_json_mcp(path: Path) -> bool:
+        try:
+            d = json.loads(path.read_text()) if path.exists() else {}
+            return "conduct" in d.get("mcpServers", {})
+        except Exception:
+            return False
+
+    def _check_json_hook(path: Path) -> bool:
+        try:
+            d = json.loads(path.read_text()) if path.exists() else {}
+            hooks = d.get("hooks", {})
+            pre = hooks.get("PreToolUse", [])
+            return any("conductguard" in str(h) or "conduct" in str(h).lower() for h in pre)
+        except Exception:
+            return False
+
+    def _check_toml_str(path: Path, needle: str) -> bool:
+        try:
+            return needle in (path.read_text() if path.exists() else "")
+        except Exception:
+            return False
+
+    tools = []
+
+    claude_dir = home / ".claude"
+    if claude_dir.exists():
+        settings = claude_dir / "settings.json"
+        tools.append({
+            "name": "claude-code",
+            "mcp_registered": _check_json_mcp(settings),
+            "hook_registered": _check_json_hook(settings),
+        })
+
+    codex_dir = home / ".codex"
+    if codex_dir.exists():
+        config = codex_dir / "config.toml"
+        tools.append({
+            "name": "codex",
+            "mcp_registered": _check_toml_str(config, "conduct-mcp"),
+            "hook_registered": _check_toml_str(config, "conductguard"),
+        })
+
+    cursor_dir = home / ".cursor"
+    if cursor_dir.exists():
+        tools.append({
+            "name": "cursor",
+            "mcp_registered": _check_json_mcp(cursor_dir / "mcp.json"),
+            "hook_registered": False,
+        })
+
+    windsurf_dir = home / ".codeium" / "windsurf"
+    if windsurf_dir.exists():
+        tools.append({
+            "name": "windsurf",
+            "mcp_registered": _check_json_mcp(windsurf_dir / "mcp_config.json"),
+            "hook_registered": False,
+        })
+
+    vscode_candidates = [
+        home / "Library" / "Application Support" / "Code" / "User" / "settings.json",
+        home / ".config" / "Code" / "User" / "settings.json",
+        home / ".vscode" / "settings.json",
+    ]
+    vscode_settings = next((p for p in vscode_candidates if p.exists()), None)
+    if vscode_settings:
+        try:
+            d = json.loads(vscode_settings.read_text())
+            mcp_reg = "conduct" in d.get("mcp", {}).get("servers", {})
+        except Exception:
+            mcp_reg = False
+        tools.append({
+            "name": "vscode",
+            "mcp_registered": mcp_reg,
+            "hook_registered": False,
+        })
+
+    if not tools:
+        return
+
+    try:
+        cfg = _load_guard_config()
+        base_url = _api_url(cfg)
+        email = cfg.get("user_email", "")
+        token = cfg.get("member_token", "")
+        api_key = cfg.get("api_key", "")
+
+        if not email:
+            return
+
+        payload = json.dumps({"email": email, "tools": tools}).encode()
+        auth = token or api_key
+        req = urllib.request.Request(
+            f"{base_url}/guard/developer-tools",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {auth}",
+            },
+            method="POST",
+        )
+        urllib.request.urlopen(req, timeout=8)
+    except Exception:
+        pass  # Never surface errors — this is background telemetry
+
+
 def cmd_guard_sync(args):
     cfg          = _require_guard_config()
     workspace_id = cfg.get("workspace_id")
@@ -861,6 +979,12 @@ def cmd_guard_sync(args):
     # Capture savings from RTK and Agent Booster
     _report_savings(cfg, base_url, api_key)
 
+    # Report AI tool coverage
+    try:
+        _report_tools_to_server()
+    except Exception:
+        pass
+
     print(f"\n{BOLD}Policy refreshed ({rule_count} rule(s)).{RESET}")
 
 

{conduct_cli-0.4.28 → conduct_cli-0.4.30}/src/conduct_cli/main.py

@@ -217,7 +217,7 @@ def _write_codex_mcp_config() -> bool:
     try:
         content = config_path.read_text() if config_path.exists() else ""
         if "conduct-mcp" in content:
-            return True  # already registered
+            return True
         mcp_block = '\n[[mcp_servers]]\nname = "conduct"\ncommand = "conduct-mcp"\nargs = []\n'
         config_path.write_text(content + mcp_block)
         return True
@@ -225,8 +225,198 @@ def _write_codex_mcp_config() -> bool:
         return False
 
 
+def _write_cursor_mcp_config() -> bool:
+    """Write conduct-mcp into ~/.cursor/mcp.json. Returns True if written."""
+    cursor_dir = Path.home() / ".cursor"
+    if not cursor_dir.exists():
+        return False
+    config_path = cursor_dir / "mcp.json"
+    try:
+        existing = json.loads(config_path.read_text()) if config_path.exists() else {}
+        servers = existing.setdefault("mcpServers", {})
+        if "conduct" in servers:
+            return True
+        servers["conduct"] = {"command": "conduct-mcp", "args": []}
+        config_path.write_text(json.dumps(existing, indent=2))
+        return True
+    except Exception:
+        return False
+
+
+def _write_windsurf_mcp_config() -> bool:
+    """Write conduct-mcp into ~/.codeium/windsurf/mcp_config.json. Returns True if written."""
+    config_path = Path.home() / ".codeium" / "windsurf" / "mcp_config.json"
+    if not config_path.parent.exists():
+        return False
+    try:
+        existing = json.loads(config_path.read_text()) if config_path.exists() else {}
+        servers = existing.setdefault("mcpServers", {})
+        if "conduct" in servers:
+            return True
+        servers["conduct"] = {"command": "conduct-mcp", "args": []}
+        config_path.write_text(json.dumps(existing, indent=2))
+        return True
+    except Exception:
+        return False
+
+
+def _write_vscode_mcp_config() -> bool:
+    """Write conduct-mcp into VS Code settings.json (mcp.servers). Returns True if written."""
+    # Check both standard locations
+    candidates = [
+        Path.home() / ".vscode" / "settings.json",
+        Path.home() / "Library" / "Application Support" / "Code" / "User" / "settings.json",
+        Path.home() / ".config" / "Code" / "User" / "settings.json",
+    ]
+    settings_path = next((p for p in candidates if p.exists()), None)
+    if not settings_path:
+        return False
+    try:
+        existing = json.loads(settings_path.read_text()) if settings_path.exists() else {}
+        servers = existing.setdefault("mcp", {}).setdefault("servers", {})
+        if "conduct" in servers:
+            return True
+        servers["conduct"] = {"command": "conduct-mcp", "args": []}
+        settings_path.write_text(json.dumps(existing, indent=2))
+        return True
+    except Exception:
+        return False
+
+
+def _detect_ai_tools() -> list:
+    """
+    Detect which AI coding tools are installed and whether Guard/conduct-mcp is registered.
+    Returns list of {name, mcp_registered, hook_registered} for each detected tool.
+    Only includes tools whose config directory exists on this machine.
+    """
+    home = Path.home()
+    results = []
+
+    def _check_json_mcp(path: Path) -> bool:
+        try:
+            d = json.loads(path.read_text()) if path.exists() else {}
+            return "conduct" in d.get("mcpServers", {})
+        except Exception:
+            return False
+
+    def _check_json_hook(path: Path, hook_key: str = "hooks") -> bool:
+        try:
+            d = json.loads(path.read_text()) if path.exists() else {}
+            hooks = d.get(hook_key, {})
+            pre = hooks.get("PreToolUse", [])
+            return any("conductguard" in str(h) or "conduct" in str(h).lower() for h in pre)
+        except Exception:
+            return False
+
+    def _check_toml_str(path: Path, needle: str) -> bool:
+        try:
+            return needle in (path.read_text() if path.exists() else "")
+        except Exception:
+            return False
+
+    # Claude Code
+    claude_dir = home / ".claude"
+    if claude_dir.exists():
+        settings = claude_dir / "settings.json"
+        results.append({
+            "name": "claude-code",
+            "mcp_registered": _check_json_mcp(settings),
+            "hook_registered": _check_json_hook(settings),
+        })
+
+    # Codex
+    codex_dir = home / ".codex"
+    if codex_dir.exists():
+        config = codex_dir / "config.toml"
+        results.append({
+            "name": "codex",
+            "mcp_registered": _check_toml_str(config, "conduct-mcp"),
+            "hook_registered": _check_toml_str(config, "conductguard"),
+        })
+
+    # Cursor
+    cursor_dir = home / ".cursor"
+    if cursor_dir.exists():
+        results.append({
+            "name": "cursor",
+            "mcp_registered": _check_json_mcp(cursor_dir / "mcp.json"),
+            "hook_registered": False,  # Cursor uses MCP only, no hook
+        })
+
+    # Windsurf
+    windsurf_dir = home / ".codeium" / "windsurf"
+    if windsurf_dir.exists():
+        results.append({
+            "name": "windsurf",
+            "mcp_registered": _check_json_mcp(windsurf_dir / "mcp_config.json"),
+            "hook_registered": False,  # Windsurf uses MCP only
+        })
+
+    # VS Code (Copilot)
+    vscode_settings_candidates = [
+        home / "Library" / "Application Support" / "Code" / "User" / "settings.json",
+        home / ".config" / "Code" / "User" / "settings.json",
+        home / ".vscode" / "settings.json",
+    ]
+    vscode_settings = next((p for p in vscode_settings_candidates if p.exists()), None)
+    if vscode_settings:
+        try:
+            d = json.loads(vscode_settings.read_text())
+            mcp_reg = "conduct" in d.get("mcp", {}).get("servers", {})
+        except Exception:
+            mcp_reg = False
+        results.append({
+            "name": "vscode",
+            "mcp_registered": mcp_reg,
+            "hook_registered": False,  # VS Code uses MCP only
+        })
+
+    return results
+
+
+def _report_tool_coverage() -> None:
+    """Detect AI tools on this machine and POST coverage to Guard API. Silent on failure."""
+    try:
+        cfg = _load_config()
+        server  = cfg.get("server", "").rstrip("/")
+        api_key = cfg.get("api_key", "")
+        token   = cfg.get("token", "")
+        email   = cfg.get("email", "")
+
+        # also check guard config for email/token
+        guard_cfg_path = Path.home() / ".conductguard" / "config.json"
+        if guard_cfg_path.exists():
+            gcfg = json.loads(guard_cfg_path.read_text())
+            if not email:
+                email = gcfg.get("user_email", "")
+            if not token:
+                token = gcfg.get("member_token", "")
+
+        if not server or not email:
+            return
+
+        tools = _detect_ai_tools()
+        if not tools:
+            return
+
+        payload = json.dumps({"email": email, "tools": tools}).encode()
+        auth = token or api_key
+        req = urllib.request.Request(
+            f"{server}/guard/developer-tools",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {auth}",
+            },
+            method="POST",
+        )
+        urllib.request.urlopen(req, timeout=8)
+    except Exception:
+        pass  # Never surface errors — this is background telemetry
+
+
 def cmd_mcp_install(args):
-    """Register conduct-mcp in Claude Code and Codex CLI."""
+    """Register conduct-mcp in Claude Code, Codex, Cursor, Windsurf, and VS Code."""
     import shutil
     import subprocess
 
@@ -242,29 +432,48 @@ def cmd_mcp_install(args):
             if result.returncode == 0:
                 registered.append("Claude Code")
             else:
-                # claude mcp add is idempotent; also try writing settings.json directly as fallback
                 _write_claude_mcp_settings()
                 registered.append("Claude Code (settings.json)")
         except Exception:
             _write_claude_mcp_settings()
             registered.append("Claude Code (settings.json)")
     else:
-        # claude CLI not found but .claude/ might exist (IDE extension)
-        written = _write_claude_mcp_settings()
-        if written:
+        if _write_claude_mcp_settings():
             registered.append("Claude Code (settings.json)")
 
     # --- Codex CLI ---
-    written = _write_codex_mcp_config()
-    if written:
+    if _write_codex_mcp_config():
         registered.append("Codex")
 
+    # --- Cursor ---
+    if _write_cursor_mcp_config():
+        registered.append("Cursor")
+
+    # --- Windsurf ---
+    if _write_windsurf_mcp_config():
+        registered.append("Windsurf")
+
+    # --- VS Code (Copilot) ---
+    if _write_vscode_mcp_config():
+        registered.append("VS Code (Copilot)")
+
     if registered:
         print(f"{GREEN}✓ conduct-mcp registered in: {', '.join(registered)}{RESET}")
-        print(f"{GRAY}  Restart Claude Code / Codex to pick up the new MCP server.{RESET}")
+        print(f"{GRAY}  Restart your AI tools to pick up the new MCP server.{RESET}")
     else:
-        print(f"{YELLOW}⚠ No supported AI tools detected. Install Claude Code or Codex first.{RESET}")
-        print(f"{GRAY}  Then re-run: conduct mcp install{RESET}")
+        print(f"{YELLOW}⚠ No supported AI tools detected on this machine.{RESET}")
+        print(f"{GRAY}  Supported: Claude Code, Codex, Cursor, Windsurf, VS Code{RESET}")
+        print(f"{GRAY}  After installing any of these, re-run: conduct mcp install{RESET}")
+
+    tools = _detect_ai_tools()
+    if tools:
+        print(f"{GRAY}  Detected tools: {', '.join(t['name'] for t in tools)}{RESET}")
+        covered = [t['name'] for t in tools if t['mcp_registered']]
+        if covered:
+            print(f"{GREEN}  MCP registered: {', '.join(covered)}{RESET}")
+        uncovered = [t['name'] for t in tools if not t['mcp_registered']]
+        if uncovered:
+            print(f"{YELLOW}  Not covered: {', '.join(uncovered)} — run: conduct mcp install{RESET}")
 
 
 def cmd_login(args):
@@ -336,6 +545,12 @@ def cmd_login(args):
     except Exception:
         pass  # Never block login on MCP registration errors
 
+    # Report tool coverage to Guard
+    try:
+        _report_tool_coverage()
+    except Exception:
+        pass
+
 
 def cmd_agents(args):
     server, workspace_id, api_key, token = _require_auth(args)

{conduct_cli-0.4.28 → conduct_cli-0.4.30}/src/conduct_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conduct-cli
-Version: 0.4.28
+Version: 0.4.30
 Summary: CLI for Conduct AI — install agents, manage projects, run tests
 Author-email: Conduct AI <hello@conductai.ai>
 License: MIT