conduct-cli 0.4.96__tar.gz → 0.4.98__tar.gz

{conduct_cli-0.4.96 → conduct_cli-0.4.98}/PKG-INFO

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

{conduct_cli-0.4.96 → conduct_cli-0.4.98}/pyproject.toml

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

{conduct_cli-0.4.96 → conduct_cli-0.4.98}/src/conduct_cli/hook_template.py

@@ -588,12 +588,21 @@ def main():
     if data.get("hook_event_name") == "Stop" or data.get("stop_hook_active"):
         session_id = data.get("session_id", "")
         transcript_path = data.get("transcript_path")
-        # Detect repo from CWD git remote
         repo = _detect_repo()
-        from conduct_cli.memory import post_session_to_api
+        from conduct_cli.memory import post_session_to_api, mark_flushed
         post_session_to_api(session_id, transcript_path, repo)
+        mark_flushed()
         sys.exit(0)
 
+    # Periodic flush — fire at most once every 8 hours mid-session
+    from conduct_cli.memory import should_periodic_flush, mark_flushed, post_session_to_api
+    if should_periodic_flush():
+        session_id = data.get("session_id", "")
+        transcript_path = data.get("transcript_path")
+        repo = _detect_repo()
+        post_session_to_api(session_id, transcript_path, repo)
+        mark_flushed()
+
     # Policy version check (cached 60s) — auto-syncs if server version differs
     _maybe_sync_policy()
 

{conduct_cli-0.4.96 → conduct_cli-0.4.98}/src/conduct_cli/main.py

@@ -156,7 +156,7 @@ def _stream_run(server: str, workflow_id: str, run_id: str, workspace_id: str, t
             print(f"{RED}    ✗ {prefix}{err}{RESET}")
         elif kind == "brain_tool_call":
             summary = payload.get("summary", payload.get("tool", ""))
-            print(f"{GRAY}      · {summary}{RESET}")
+            print(f"      · {summary}{RESET}")
         elif kind == "run_completed":
             print(f"{BOLD}{GREEN}    ✓ done{RESET}")
         elif kind == "run_failed":
@@ -198,92 +198,36 @@ def _poll_run(server: str, workflow_id: str, run_id: str, hdrs: dict) -> bool:
 
 # ── Commands ──────────────────────────────────────────────────────────────────
 
-def _write_claude_mcp_settings() -> bool:
-    """Write conduct-mcp into ~/.claude/settings.json. Returns True if written."""
-    settings_path = Path.home() / ".claude" / "settings.json"
-    try:
-        existing = json.loads(settings_path.read_text()) if settings_path.exists() else {}
-        servers = existing.setdefault("mcpServers", {})
-        if "conduct" in servers:
-            return True  # already registered
-        servers["conduct"] = {"command": "conduct-mcp", "args": []}
-        settings_path.parent.mkdir(parents=True, exist_ok=True)
-        settings_path.write_text(json.dumps(existing, indent=2))
-        return True
-    except Exception:
-        return False
-
-
-def _write_codex_mcp_config() -> bool:
-    """Write conduct-mcp into ~/.codex/config.toml. Returns True if written."""
-    codex_dir = Path.home() / ".codex"
-    if not codex_dir.exists():
-        return False
-    config_path = codex_dir / "config.toml"
-    try:
-        content = config_path.read_text() if config_path.exists() else ""
-        if "conduct-mcp" in content:
-            return True
-        mcp_block = '\n[mcp_servers.conduct]\ncommand = "conduct-mcp"\nargs = []\n'
-        config_path.write_text(content + mcp_block)
-        return True
-    except Exception:
-        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():
+def _write_mcp_config(path: Path, *, keys: tuple = ("mcpServers",), create: bool = False) -> bool:
+    """Write conduct-mcp entry into a JSON config file. Returns True if written or already present."""
+    if not create and not path.parent.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", {})
+        existing = json.loads(path.read_text()) if path.exists() else {}
+        node = existing
+        for k in keys[:-1]:
+            node = node.setdefault(k, {})
+        servers = node.setdefault(keys[-1], {})
         if "conduct" in servers:
             return True
         servers["conduct"] = {"command": "conduct-mcp", "args": []}
-        config_path.write_text(json.dumps(existing, indent=2))
+        path.parent.mkdir(parents=True, exist_ok=True)
+        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"
+def _write_codex_mcp_config() -> bool:
+    """Write conduct-mcp into ~/.codex/config.toml (TOML — different format)."""
+    config_path = Path.home() / ".codex" / "config.toml"
     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:
+        content = config_path.read_text() if config_path.exists() else ""
+        if "conduct-mcp" in content:
             return True
-        servers["conduct"] = {"command": "conduct-mcp", "args": []}
-        settings_path.write_text(json.dumps(existing, indent=2))
+        config_path.write_text(content + '\n[mcp_servers.conduct]\ncommand = "conduct-mcp"\nargs = []\n')
         return True
     except Exception:
         return False
@@ -427,30 +371,26 @@ def cmd_mcp_install(args):
     import shutil
     import subprocess
 
-    registered = []
-
-    # --- Claude Code ---
-    # Write directly to ~/.claude/settings.json — `claude mcp add` without --global
-    # writes to the project-level .claude/settings.json which _detect_ai_tools won't find.
-    if _write_claude_mcp_settings():
-        registered.append("Claude Code")
+    home = Path.home()
+    # claude mcp add --global writes to project-level settings; write directly instead.
+    _MCP_TARGETS = [
+        ("Claude Code",      home / ".claude" / "settings.json",                             ("mcpServers",),    True),
+        ("Cursor",           home / ".cursor" / "mcp.json",                                  ("mcpServers",),    False),
+        ("Windsurf",         home / ".codeium" / "windsurf" / "mcp_config.json",             ("mcpServers",),    False),
+        ("VS Code (Copilot)",next((p for p in [
+            home / ".vscode" / "settings.json",
+            home / "Library" / "Application Support" / "Code" / "User" / "settings.json",
+            home / ".config" / "Code" / "User" / "settings.json",
+        ] if p.exists()), None),                                                              ("mcp", "servers"), False),
+    ]
 
-    # --- Codex CLI ---
+    registered = []
+    for label, path, keys, create in _MCP_TARGETS:
+        if path and _write_mcp_config(path, keys=keys, create=create):
+            registered.append(label)
     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 your AI tools to pick up the new MCP server.{RESET}")
@@ -676,47 +616,38 @@ def cmd_test(args):
             })
         return payload
 
-    if parallel:
-        _run_tests_parallel(server, workspace_id, api_key, token, hdrs, targets, _build_payload)
-    else:
-        _run_tests_serial(server, workspace_id, api_key, token, hdrs, targets, _build_payload)
+    _run_tests(server, workspace_id, api_key, token, hdrs, targets, _build_payload, parallel=parallel)
 
 
-def _run_tests_serial(server, workspace_id, api_key, token, hdrs, targets, build_payload):
-    results = []
-    for wf in targets:
-        name  = wf["name"]
-        wf_id = str(wf["id"])
-        slug  = wf.get("playbook_slug", "")
+def _run_tests(server, workspace_id, api_key, token, hdrs, targets, build_payload, *, parallel: bool = False):
+    import threading
 
-        print(f"{CYAN}── {name}{RESET} {GRAY}({slug}){RESET}")
-        try:
-            run = api.req("POST", f"{server}/workflows/{wf_id}/trigger", hdrs, build_payload(slug))
-        except SystemExit:
-            results.append((name, False, None))
+    if not parallel:
+        results = []
+        for wf in targets:
+            name  = wf["name"]
+            wf_id = str(wf["id"])
+            slug  = wf.get("playbook_slug", "")
+            print(f"{CYAN}── {name}{RESET} {GRAY}({slug}){RESET}")
+            try:
+                run = api.req("POST", f"{server}/workflows/{wf_id}/trigger", hdrs, build_payload(slug))
+            except SystemExit:
+                results.append((name, False, None))
+                print()
+                continue
+            run_id = run.get("run_id")
+            print(f"  {GRAY}run: {run_id}{RESET}")
+            try:
+                ok = _stream_run(server, wf_id, run_id, workspace_id, token, api_key)
+            except Exception:
+                ok = _poll_run(server, wf_id, run_id, hdrs)
+            results.append((name, ok, run_id))
             print()
-            continue
-
-        run_id = run.get("run_id")
-        print(f"  {GRAY}run: {run_id}{RESET}")
-
-        try:
-            ok = _stream_run(server, wf_id, run_id, workspace_id, token, api_key)
-        except Exception:
-            ok = _poll_run(server, wf_id, run_id, hdrs)
-
-        results.append((name, ok, run_id))
-        print()
-
-    _print_results(results)
-
-
-def _run_tests_parallel(server, workspace_id, api_key, token, hdrs, targets, build_payload):
-    """Fire all triggers immediately, then poll all runs concurrently."""
-    import threading
+        _print_results(results)
+        return
 
-    # Phase 1: fire all triggers at once
-    pending = []  # list of (name, run_id) or (name, None) on trigger failure
+    # parallel: fire all triggers, then poll concurrently
+    pending = []
     for wf in targets:
         name  = wf["name"]
         wf_id = str(wf["id"])
@@ -731,7 +662,6 @@ def _run_tests_parallel(server, workspace_id, api_key, token, hdrs, targets, bui
             pending.append((name, wf_id, None))
 
     print(f"\n  Polling {len(pending)} runs concurrently…\n")
-
     results_lock = threading.Lock()
     results: list = [None] * len(pending)
 
@@ -754,7 +684,6 @@ def _run_tests_parallel(server, workspace_id, api_key, token, hdrs, targets, bui
         t.start()
     for t in threads:
         t.join()
-
     _print_results(results)
 
 

{conduct_cli-0.4.96 → conduct_cli-0.4.98}/src/conduct_cli/memory.py

@@ -3,9 +3,31 @@ from __future__ import annotations
 
 import json
 import threading
+import time
 import urllib.request
 from pathlib import Path
 
+_FLUSH_INTERVAL = 8 * 3600  # 8 hours in seconds
+_FLUSH_STAMP = Path.home() / ".conduct" / "last_memory_flush"
+
+
+def should_periodic_flush() -> bool:
+    """True if 8+ hours have passed since the last periodic memory flush."""
+    try:
+        if not _FLUSH_STAMP.exists():
+            return True
+        return time.time() - float(_FLUSH_STAMP.read_text().strip()) >= _FLUSH_INTERVAL
+    except Exception:
+        return True
+
+
+def mark_flushed() -> None:
+    try:
+        _FLUSH_STAMP.parent.mkdir(parents=True, exist_ok=True)
+        _FLUSH_STAMP.write_text(str(time.time()))
+    except Exception:
+        pass
+
 
 def _load_config():
     cfg_path = Path.home() / ".conduct" / "config.json"

{conduct_cli-0.4.96 → conduct_cli-0.4.98}/src/conduct_cli.egg-info/PKG-INFO

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