nexus-toolkit 2.3.4__tar.gz → 2.3.6__tar.gz

{nexus_toolkit-2.3.4 → nexus_toolkit-2.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexus-toolkit
-Version: 2.3.4
+Version: 2.3.6
 Summary: Hybrid search, retrieval, and Figma Make boilerplate generation MCP server
 Author-email: Ronald dela Cruz <rcdelacruz@users.noreply.github.com>
 License-Expression: MIT

{nexus_toolkit-2.3.4 → nexus_toolkit-2.3.6}/nexus_cli.py

@@ -19,10 +19,13 @@ All commands read from / write to /tmp/nexus-<project_name>/ automatically.
 import asyncio
 import base64
 import json
+import os
 import pathlib
+import re
 import shutil
 import subprocess
 import sys
+import threading
 from typing import Annotated, Optional
 
 import typer
@@ -99,7 +102,15 @@ _THEME = Theme({
 console = Console(theme=_THEME)
 
 
-_VERSION = "2.3.4"
+try:
+    from importlib.metadata import version as _pkg_version
+    _VERSION = _pkg_version("nexus-toolkit")
+except Exception:
+    _VERSION = "2.3.5"
+
+_MAX_DISPLAY_ERRORS = 15
+_MAX_DISPLAY_WARNINGS = 5
+_AGENT_HTTP_TIMEOUT_S = 300
 
 _LOGO = """\
 [cyan]███╗   ██╗███████╗██╗  ██╗██╗   ██╗███████╗[/cyan]
@@ -172,15 +183,9 @@ def _print_success(zip_path: pathlib.Path, total_files: int, size_kb: int) -> No
 def _print_errors(errors: list, warnings: list, project_name: str) -> None:
     console.print()
     console.print(Rule(style="bright_black"))
-    lines = []
-    for e in errors[:15]:
-        lines.append(Text.assemble(("  ✗ ", "bold red"), (e, "white")))
-    for w in warnings[:5]:
-        lines.append(Text.assemble(("  ⚠ ", "bold yellow"), (w, "dim white")))
-    content = "\n".join(str(l) for l in lines)
     console.print(Panel(
-        "\n".join(f"  [red]✗[/red] {e}" for e in errors[:15]) +
-        ("" if not warnings else "\n" + "\n".join(f"  [yellow]⚠[/yellow] {w}" for w in warnings[:5])),
+        "\n".join(f"  [red]✗[/red] {e}" for e in errors[:_MAX_DISPLAY_ERRORS]) +
+        ("" if not warnings else "\n" + "\n".join(f"  [yellow]⚠[/yellow] {w}" for w in warnings[:_MAX_DISPLAY_WARNINGS])),
         title="[bold red] validation failed [/bold red]",
         border_style="red",
         box=box.ROUNDED,
@@ -194,6 +199,7 @@ def _print_errors(errors: list, warnings: list, project_name: str) -> None:
 
 def _cache_json(project_name: str) -> str:
     """Return the minimal JSON needed to point validate/package at the cache."""
+    project_name = re.sub(r"[^a-zA-Z0-9_-]", "-", project_name)
     return json.dumps({"_nexus_cache": f"/tmp/nexus-{project_name}"})
 
 
@@ -233,8 +239,6 @@ def _find_claude(claude_path: Optional[str] = None) -> str:
     3. PATH (shutil.which)
     4. ~/.local/bin/claude (standard Claude Code install on macOS/Linux)
     """
-    import os
-
     candidate = claude_path or os.environ.get("CLAUDE_PATH")
     if candidate:
         p = pathlib.Path(candidate).expanduser()
@@ -274,7 +278,6 @@ Rules:
 
 def _decompose_description(description: str, claude_bin: str, model: str) -> tuple[list[str], list[str]]:
     """Call claude CLI to decompose a description into pages and components."""
-    import subprocess
     result = subprocess.run(
         [claude_bin, "--print", "--model", model, "--system-prompt", _DECOMPOSE_SYSTEM, description],
         capture_output=True, text=True,
@@ -423,7 +426,7 @@ def _root(
     console.print()
     if version:
         raise typer.Exit()
-    _check_update()
+    threading.Thread(target=_check_update, daemon=True).start()
     if help or ctx.invoked_subcommand is None:
         _print_help()
         raise typer.Exit()
@@ -434,7 +437,6 @@ def _root(
 @app.command("update")
 def update() -> None:
     """Upgrade nexus-toolkit to the latest version from PyPI."""
-    import subprocess
     installer = shutil.which("uv")
     if installer:
         cmd = ["uv", "tool", "install", "--reinstall", "--force", "nexus-toolkit"]
@@ -912,7 +914,7 @@ def _validate_and_package(tools, project_name, output_dir, cache):
 
     # Validate
     with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), TimeElapsedColumn(), console=console, transient=True) as p:
-        p.add_task("  4/4  validating…")
+        p.add_task("  4/5  validating…")
         raw = asyncio.run(tools["validate_output"](file_tree_json))
     val_data = _parse_result(raw, "validate")
     passed = val_data.get("passed", False)
@@ -922,7 +924,7 @@ def _validate_and_package(tools, project_name, output_dir, cache):
         _step_error("validate", f"{val_data.get('error_count', 0)} error(s)")
         _print_errors(errors, warnings, project_name)
         raise typer.Exit(1)
-    _step_done(4, 4, "validate", f"passed · {val_data.get('warning_count', 0)} warning(s)")
+    _step_done(4, 5, "validate", f"passed · {val_data.get('warning_count', 0)} warning(s)")
 
     # Package
     with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), TimeElapsedColumn(), console=console, transient=True) as p:
@@ -978,11 +980,13 @@ def _find_dev_agent(agent_name: str) -> pathlib.Path:
         candidate = _DEV_AGENTS_DIR / subdir / f"{agent_name}.md"
         if candidate.exists():
             return candidate
-    for p in _DEV_AGENTS_DIR.rglob(f"{agent_name}.md"):
-        return p
+    results = sorted(_DEV_AGENTS_DIR.rglob(f"{agent_name}.md"))
+    if results:
+        return results[0]
     # uvx-installed fallback
-    for p in pathlib.Path(__file__).parent.rglob(f"dev-agents/**/{agent_name}.md"):
-        return p
+    fallback_results = sorted(pathlib.Path(__file__).parent.rglob(f"dev-agents/**/{agent_name}.md"))
+    if fallback_results:
+        return fallback_results[0]
     available = ", ".join(sorted(_DEV_AGENT_REGISTRY.keys()))
     console.print(f"[red]✗ Agent not found:[/red] {agent_name}")
     console.print(f"  Available: [dim]{available}[/dim]")
@@ -998,9 +1002,13 @@ def _find_workflow(workflow_name: str) -> pathlib.Path:
     for p in candidates:
         if p.exists():
             return p
-    workflows = sorted(p.stem for p in (_NEXUS_ROOT / ".claude" / "commands").glob("*.md"))
+    commands_dir = _NEXUS_ROOT / ".claude" / "commands"
+    if not commands_dir.exists():
+        workflows: list[str] = []
+    else:
+        workflows = sorted(p.stem for p in commands_dir.glob("*.md"))
     console.print(f"[red]✗ Workflow not found:[/red] {workflow_name}")
-    console.print(f"  Available: [dim]{', '.join(workflows)}[/dim]")
+    console.print(f"  Available: [dim]{', '.join(workflows) if workflows else '(none)'}[/dim]")
     raise typer.Exit(1)
 
 
@@ -1025,6 +1033,94 @@ def agent_list() -> None:
     console.print()
 
 
+# ── nexus agent run (remote helper) ──────────────────────────────────────────
+
+def _agent_run_remote(
+    server_url: str,
+    agent_name: str,
+    file_path: Optional[pathlib.Path],
+    context: Optional[str],
+    model: str,
+) -> None:
+    """Send run_agent to a remote Nexus MCP HTTP server and stream the findings."""
+    import sys as _sys
+    import urllib.request
+    import urllib.error
+
+    if context:
+        input_text = context
+        source_label = "inline context"
+    elif file_path and str(file_path) == "-":
+        input_text = _sys.stdin.read()
+        source_label = "stdin"
+    elif file_path:
+        if not file_path.exists():
+            console.print(f"[red]✗ File not found:[/red] {file_path}")
+            raise typer.Exit(1)
+        input_text = file_path.read_text(encoding="utf-8", errors="replace")
+        source_label = str(file_path)
+    else:
+        console.print("[red]✗ Provide a file path or --context string.[/red]")
+        raise typer.Exit(1)
+
+    meta = Table.grid(padding=(0, 2))
+    meta.add_column(style="dim white", min_width=12)
+    meta.add_column(style="white")
+    meta.add_row("agent", f"[cyan]{agent_name}[/cyan]")
+    meta.add_row("source", source_label)
+    meta.add_row("model", model)
+    meta.add_row("server", server_url)
+    console.print()
+    console.print(Panel(meta, title="[bold] nexus agent run [/bold]", box=box.ROUNDED, border_style="bright_black", padding=(0, 1)))
+    console.print()
+
+    payload = json.dumps({
+        "jsonrpc": "2.0",
+        "method": "tools/call",
+        "params": {
+            "name": "run_agent",
+            "arguments": {
+                "agent_name": agent_name,
+                "context": input_text,
+                "model": model,
+            },
+        },
+        "id": 1,
+    }).encode()
+
+    req = urllib.request.Request(
+        server_url,
+        data=payload,
+        headers={"Content-Type": "application/json", "Accept": "application/json"},
+        method="POST",
+    )
+
+    console.print(Rule(agent_name, style="bright_black"))
+    console.print()
+
+    try:
+        with urllib.request.urlopen(req, timeout=_AGENT_HTTP_TIMEOUT_S) as resp:
+            raw = resp.read().decode()
+    except urllib.error.URLError as exc:
+        console.print(f"[red]✗ Remote error:[/red] {exc}")
+        raise typer.Exit(1)
+
+    try:
+        data = json.loads(raw)
+        # MCP response: {"result": {"content": [{"type": "text", "text": "<json>"}]}}
+        result = data.get("result", {})
+        content = result.get("content", []) if isinstance(result, dict) else []
+        text = content[0].get("text", "") if content else raw
+        inner = json.loads(text) if text else {}
+        findings = inner.get("findings") or inner.get("error") or text or raw
+    except Exception:
+        findings = raw
+
+    console.print(findings)
+    console.print()
+    console.print(Rule(style="bright_black"))
+
+
 # ── nexus agent run ───────────────────────────────────────────────────────────
 
 
@@ -1051,11 +1147,18 @@ def agent_run(
     remember: Annotated[
         bool, typer.Option("--remember", help="Write findings back to memory after run.")
     ] = False,
+    server: Annotated[
+        Optional[str], typer.Option("--server", help="Remote Nexus MCP server URL (e.g. http://host:3900/mcp).")
+    ] = None,
 ) -> None:
     """Run a dev-workflow agent (e.g. code-reviewer, security) against a file or inline context."""
     import sys as _sys
     from tools.devsecops.memory import build_memory_context_block, update_memory
 
+    if server:
+        _agent_run_remote(server, agent_name, file_path, context, model)
+        return
+
     agent_file = _find_dev_agent(agent_name)
 
     if context:
@@ -1126,7 +1229,9 @@ def agent_run(
             # Stream output to terminal while capturing for memory write
             import io as _io
             proc = subprocess.Popen(cmd, text=True, stdout=subprocess.PIPE, stderr=None)
-            assert proc.stdout is not None
+            if proc.stdout is None:
+                proc.kill()
+                raise RuntimeError("subprocess stdout unavailable")
             buf = _io.StringIO()
             for line in proc.stdout:
                 print(line, end="", flush=True)

{nexus_toolkit-2.3.4 → nexus_toolkit-2.3.6}/nexus_toolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nexus-toolkit
-Version: 2.3.4
+Version: 2.3.6
 Summary: Hybrid search, retrieval, and Figma Make boilerplate generation MCP server
 Author-email: Ronald dela Cruz <rcdelacruz@users.noreply.github.com>
 License-Expression: MIT

{nexus_toolkit-2.3.4 → nexus_toolkit-2.3.6}/nexus_toolkit.egg-info/SOURCES.txt

@@ -560,6 +560,7 @@ nexus_toolkit.egg-info/dependency_links.txt
 nexus_toolkit.egg-info/entry_points.txt
 nexus_toolkit.egg-info/requires.txt
 nexus_toolkit.egg-info/top_level.txt
+tests/test_agent_runner.py
 tests/test_figma_pipeline.py
 tests/test_improvements.py
 tests/test_mcp_protocol.py

{nexus_toolkit-2.3.4 → nexus_toolkit-2.3.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nexus-toolkit"
-version = "2.3.4"
+version = "2.3.6"
 description = "Hybrid search, retrieval, and Figma Make boilerplate generation MCP server"
 authors = [
     {name = "Ronald dela Cruz", email = "rcdelacruz@users.noreply.github.com"}

nexus_toolkit-2.3.6/tests/test_agent_runner.py

@@ -0,0 +1,148 @@
+"""Tests for tools/devsecops/agent_runner.py"""
+
+import json
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from tools.devsecops.agent_runner import _load_dev_agent, register_devsecops_tools
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+
+def _extract_tool(tool_name: str):
+    """Pull a named async tool function out of register_devsecops_tools."""
+    captured = {}
+    mock_mcp = MagicMock()
+
+    def _tool_decorator(fn):
+        captured[fn.__name__] = fn
+        return fn
+
+    mock_mcp.tool.return_value = _tool_decorator
+    register_devsecops_tools(mock_mcp)
+    return captured[tool_name]
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# _load_dev_agent
+# ══════════════════════════════════════════════════════════════════════════════
+
+
+class TestLoadDevAgent:
+
+    def test_returns_content_for_known_agent(self):
+        content = _load_dev_agent("code-reviewer")
+        assert isinstance(content, str)
+        assert len(content) > 0
+
+    def test_known_agent_content_is_non_empty_string(self):
+        content = _load_dev_agent("security")
+        assert content.strip() != ""
+
+    def test_returns_empty_string_for_unknown_agent(self):
+        """Unknown agent name should raise FileNotFoundError, not return empty string."""
+        with pytest.raises(FileNotFoundError) as exc_info:
+            _load_dev_agent("nonexistent-agent-xyz")
+        assert "nonexistent-agent-xyz" in str(exc_info.value)
+
+    def test_error_message_lists_available_agents(self):
+        with pytest.raises(FileNotFoundError) as exc_info:
+            _load_dev_agent("does-not-exist")
+        assert "code-reviewer" in str(exc_info.value)
+
+    def test_all_registered_agents_loadable(self):
+        """Every agent in the registry must resolve to a real file."""
+        from tools.devsecops.agent_runner import _AGENT_REGISTRY
+        for agent_name in _AGENT_REGISTRY:
+            content = _load_dev_agent(agent_name)
+            assert len(content) > 0, f"Empty content for agent: {agent_name}"
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# run_agent — Claude Code mode (CLAUDECODE env var)
+# ══════════════════════════════════════════════════════════════════════════════
+
+
+class TestRunAgentClaudeCodeMode:
+
+    @pytest.mark.asyncio
+    async def test_claudecode_mode_returns_system_prompt(self):
+        """When CLAUDECODE=1 is set, run_agent returns system_prompt without subprocess."""
+        run_agent = _extract_tool("run_agent")
+        with patch.dict(os.environ, {"CLAUDECODE": "1"}):
+            raw = await run_agent(agent_name="code-reviewer", context="Review this code: x = 1")
+        result = json.loads(raw)
+        assert "error" not in result
+        assert "system_prompt" in result
+        assert len(result["system_prompt"]) > 0
+
+    @pytest.mark.asyncio
+    async def test_claudecode_mode_returns_user_message(self):
+        """The context is returned as user_message in Claude Code mode."""
+        run_agent = _extract_tool("run_agent")
+        context_text = "Check security of this snippet: password = '123'"
+        with patch.dict(os.environ, {"CLAUDECODE": "1"}):
+            raw = await run_agent(agent_name="security", context=context_text)
+        result = json.loads(raw)
+        assert "user_message" in result
+        assert context_text in result["user_message"]
+
+    @pytest.mark.asyncio
+    async def test_claudecode_mode_returns_agent_name(self):
+        run_agent = _extract_tool("run_agent")
+        with patch.dict(os.environ, {"CLAUDECODE": "1"}):
+            raw = await run_agent(agent_name="code-reviewer", context="some code")
+        result = json.loads(raw)
+        assert result["agent"] == "code-reviewer"
+
+    @pytest.mark.asyncio
+    async def test_claudecode_mode_no_subprocess(self):
+        """In Claude Code mode, no subprocess should be spawned."""
+        run_agent = _extract_tool("run_agent")
+        with patch.dict(os.environ, {"CLAUDECODE": "1"}):
+            with patch("asyncio.create_subprocess_exec") as mock_exec:
+                await run_agent(agent_name="code-reviewer", context="code here")
+                mock_exec.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_claudecode_env_var_controls_branch(self):
+        """Without CLAUDECODE set, the subprocess branch is attempted (not the prompt-return branch)."""
+        run_agent = _extract_tool("run_agent")
+        env_without_claudecode = {k: v for k, v in os.environ.items() if k != "CLAUDECODE"}
+        with patch.dict(os.environ, env_without_claudecode, clear=True):
+            # Patch _find_claude to avoid needing a real binary installed
+            with patch("tools.devsecops.agent_runner._find_claude", return_value=None):
+                raw = await run_agent(agent_name="code-reviewer", context="some code")
+        result = json.loads(raw)
+        # Without CLAUDECODE, it falls through to subprocess path.
+        # If claude is not found, it should return an error about the CLI.
+        assert "error" in result
+        assert "claude" in result["error"].lower()
+
+    @pytest.mark.asyncio
+    async def test_claudecode_mode_unknown_agent_returns_error(self):
+        """Unknown agent name should return an error JSON, not raise."""
+        run_agent = _extract_tool("run_agent")
+        with patch.dict(os.environ, {"CLAUDECODE": "1"}):
+            raw = await run_agent(agent_name="nonexistent-agent-xyz", context="code")
+        result = json.loads(raw)
+        assert "error" in result
+        assert "nonexistent-agent-xyz" in result["error"]
+
+    @pytest.mark.asyncio
+    async def test_claudecode_mode_remember_adds_after_response(self):
+        """When remember=True, after_response instructions are included."""
+        run_agent = _extract_tool("run_agent")
+        with patch.dict(os.environ, {"CLAUDECODE": "1"}):
+            raw = await run_agent(
+                agent_name="code-reviewer",
+                context="some code",
+                memory_path="/tmp/test-memory-agents",
+                remember=True,
+            )
+        result = json.loads(raw)
+        assert "after_response" in result
+        assert len(result["after_response"]) > 0

{nexus_toolkit-2.3.4 → nexus_toolkit-2.3.6}/tests/test_figma_pipeline.py

@@ -154,7 +154,7 @@ class TestIngestFigmaZip:
 
     @pytest.mark.asyncio
     async def test_all_golden_paths_accepted(self):
-        for path in ["nextjs-fullstack", "nextjs-static", "t3-stack", "vite-spa", "monorepo", "full-stack-rn"]:
+        for path in ["nextjs-fullstack", "nextjs-static", "t3-stack", "vite-spa", "monorepo", "full-stack-rn", "full-stack-flutter"]:
             result = json.loads(await self.tool(SAMPLE_ZIP_B64, golden_path=path))
             assert "error" not in result, f"Failed for golden_path={path}"
 
@@ -446,7 +446,7 @@ class TestUpdateFileInTree:
 
 # ── ingest_from_prompt tests ──────────────────────────────────────────────────
 
-from tools.figma.prompt_ingest import register_prompt_ingest_tool, _infer_components, _hint_for
+from tools.figma.prompt_ingest import register_prompt_ingest_tool
 
 
 _prompt_ingest = _extract_tool(register_prompt_ingest_tool)
@@ -489,6 +489,8 @@ class TestIngestFromPrompt:
             description="A landing page with a hero section and footer",
             golden_path="nextjs-static",
             project_name="test-infer",
+            pages=["LandingPage"],
+            components=["HeroSection", "Footer"],
         ))
         assert result["summary"]["components"] + result["summary"]["pages"] > 0
         assert result["total_files"] > 0
@@ -519,13 +521,16 @@ class TestIngestFromPrompt:
 
     @pytest.mark.asyncio
     async def test_scaffold_fallback_creates_one_page(self):
-        """With no matching signals, should fall back to a single HomePage."""
+        """With explicit page provided, total_files should reflect it."""
         result = json.loads(await _prompt_ingest(
             description="scaffold a clean project",
             golden_path="nextjs-fullstack",
             project_name="test-scaffold",
+            pages=["HomePage"],
+            components=[],
         ))
         assert result["total_files"] >= 1
+        assert result["summary"]["pages"] == 1
 
     @pytest.mark.asyncio
     async def test_writes_cache_file(self, tmp_path):
@@ -541,47 +546,6 @@ class TestIngestFromPrompt:
         assert manifest["golden_path"] == "nextjs-static"
 
 
-class TestInferComponents:
-
-    def test_landing_page_infers_home_page(self):
-        pages, _ = _infer_components("A landing page for our product")
-        assert "HomePage" in pages
-
-    def test_dashboard_inferred(self):
-        pages, _ = _infer_components("An admin dashboard with charts")
-        assert "DashboardPage" in pages
-
-    def test_hero_inferred_as_component(self):
-        _, components = _infer_components("A site with a big hero section")
-        assert "HeroSection" in components
-
-    def test_footer_inferred_as_component(self):
-        _, components = _infer_components("Include a footer with links")
-        assert "Footer" in components
-
-    def test_no_signals_returns_fallback(self):
-        pages, components = _infer_components("scaffold a clean project")
-        assert pages == ["HomePage"]
-        assert components == []
-
-    def test_no_duplicates(self):
-        pages, components = _infer_components(
-            "A landing page homepage with a hero and hero banner"
-        )
-        all_names = pages + components
-        assert len(all_names) == len(set(all_names))
-
-
-class TestHintFor:
-
-    def test_known_stem_returns_hint(self):
-        assert "hero" in _hint_for("HeroSection").lower()
-
-    def test_unknown_stem_returns_default(self):
-        hint = _hint_for("WeirdComponentXYZ")
-        assert len(hint) > 0  # returns _DEFAULT_HINT, not empty
-
-
 # ── ingest_from_codebase tests ────────────────────────────────────────────────
 
 from tools.figma.codebase_ingest import register_codebase_ingest_tool

{nexus_toolkit-2.3.4 → nexus_toolkit-2.3.6}/tools/dev-agents/cross-cutting/code-reviewer.md

@@ -5,7 +5,19 @@ tools: Read, Write, Edit, Bash, Grep, Glob
 model: sonnet
 ---
 
-You are an expert Code Reviewer specializing in TypeScript, React, Next.js, and modern web development best practices.
+You are an expert Code Reviewer. Before reviewing any code, you MUST first discover the context of the repo you are working in.
+
+## Step 1: Discover Repo Context (MANDATORY — do this before anything else)
+
+Run these in order and use what you find to inform every part of your review:
+
+1. **Read project docs** — look for `CLAUDE.md`, `README.md`, `.cursor/rules`, or any `docs/` overview files. These define conventions you must follow.
+2. **Identify the stack** — read `package.json`, `pyproject.toml`, `pom.xml`, `go.mod`, `Cargo.toml`, or equivalent. Note the framework, language, and key dependencies.
+3. **Check project structure** — run `find . -maxdepth 3 -type f | grep -v node_modules | grep -v .git | head -60` to understand the file layout and naming conventions.
+4. **Sample existing code** — read 2–3 representative source files to understand the actual patterns in use (naming, imports, error handling, component structure, etc.).
+5. **Check linting/formatting config** — read `.eslintrc`, `biome.json`, `prettier.config.*`, `pyproject.toml [tool.ruff]`, etc. Review against what is actually configured, not assumed defaults.
+
+Only after completing the above should you begin the review. Adapt all feedback to what you found — do not apply patterns from a different stack.
 
 ## Review Checklist
 

{nexus_toolkit-2.3.4 → nexus_toolkit-2.3.6}/tools/devsecops/agent_runner.py

@@ -13,6 +13,9 @@ logger = logging.getLogger(__name__)
 _NEXUS_ROOT = pathlib.Path(__file__).parent.parent.parent
 _DEV_AGENTS_DIR = pathlib.Path(__file__).parent.parent / "dev-agents"
 
+_AGENT_IDLE_TIMEOUT_S = 240
+_AGENT_HTTP_TIMEOUT_S = 300
+
 # Registry maps agent name → subdirectory within tools/dev-agents/
 _AGENT_REGISTRY: dict[str, str] = {
     # cross-cutting
@@ -53,12 +56,14 @@ def _load_dev_agent(agent_name: str) -> str:
             return candidate.read_text(encoding="utf-8")
 
     # Fallback: glob across all subdirs (handles uvx-installed paths)
-    for md_file in _DEV_AGENTS_DIR.rglob(f"{agent_name}.md"):
-        return md_file.read_text(encoding="utf-8")
+    results = sorted(_DEV_AGENTS_DIR.rglob(f"{agent_name}.md"))
+    if results:
+        return results[0].read_text(encoding="utf-8")
 
     # Last resort: search relative to this file's installed location
-    for candidate in pathlib.Path(__file__).parent.rglob(f"{agent_name}.md"):
-        return candidate.read_text(encoding="utf-8")
+    fallback_results = sorted(pathlib.Path(__file__).parent.rglob(f"{agent_name}.md"))
+    if fallback_results:
+        return fallback_results[0].read_text(encoding="utf-8")
 
     available = ", ".join(sorted(_AGENT_REGISTRY.keys()))
     raise FileNotFoundError(
@@ -203,11 +208,12 @@ def register_devsecops_tools(mcp: FastMCP) -> None:
             "--dangerously-skip-permissions",
             "--model", resolved_model,
             "--output-format", "stream-json",
+            "--verbose",
             "--system-prompt", system_prompt,
             user_message,
         ]
 
-        idle_timeout = 240
+        idle_timeout = _AGENT_IDLE_TIMEOUT_S
 
         try:
             proc = await asyncio.create_subprocess_exec(
@@ -218,8 +224,9 @@ def register_devsecops_tools(mcp: FastMCP) -> None:
             )
 
             chunks: list[str] = []
-            assert proc.stdout is not None
-            assert proc.stderr is not None
+            if proc.stdout is None or proc.stderr is None:
+                proc.kill()
+                return json.dumps({"error": "subprocess stdout/stderr unavailable"})
 
             while True:
                 try:
@@ -257,7 +264,7 @@ def register_devsecops_tools(mcp: FastMCP) -> None:
                 try:
                     event = json.loads(line)
                     if event.get("type") == "result":
-                        findings = event.get("result", "")
+                        findings = event.get("result") or event.get("content") or event.get("text") or ""
                         break
                 except json.JSONDecodeError:
                     continue