strix-agent 0.1.1__py3-none-any.whl

strix/tools/file_edit/file_edit_actions.py

@@ -0,0 +1,141 @@
+import json
+import re
+from pathlib import Path
+from typing import Any, cast
+
+from openhands_aci import file_editor
+from openhands_aci.utils.shell import run_shell_cmd
+
+from strix.tools.registry import register_tool
+
+
+def _parse_file_editor_output(output: str) -> dict[str, Any]:
+    try:
+        pattern = r"<oh_aci_output_[^>]+>\n(.*?)\n</oh_aci_output_[^>]+>"
+        match = re.search(pattern, output, re.DOTALL)
+
+        if match:
+            json_str = match.group(1)
+            data = json.loads(json_str)
+            return cast("dict[str, Any]", data)
+        return {"output": output, "error": None}
+    except (json.JSONDecodeError, AttributeError):
+        return {"output": output, "error": None}
+
+
+@register_tool
+def str_replace_editor(
+    command: str,
+    path: str,
+    file_text: str | None = None,
+    view_range: list[int] | None = None,
+    old_str: str | None = None,
+    new_str: str | None = None,
+    insert_line: int | None = None,
+) -> dict[str, Any]:
+    try:
+        path_obj = Path(path)
+        if not path_obj.is_absolute():
+            path = str(Path("/workspace") / path_obj)
+
+        result = file_editor(
+            command=command,
+            path=path,
+            file_text=file_text,
+            view_range=view_range,
+            old_str=old_str,
+            new_str=new_str,
+            insert_line=insert_line,
+        )
+
+        parsed = _parse_file_editor_output(result)
+
+        if parsed.get("error"):
+            return {"error": parsed["error"]}
+
+        return {"content": parsed.get("output", result)}
+
+    except (OSError, ValueError) as e:
+        return {"error": f"Error in {command} operation: {e!s}"}
+
+
+@register_tool
+def list_files(
+    path: str,
+    recursive: bool = False,
+) -> dict[str, Any]:
+    try:
+        path_obj = Path(path)
+        if not path_obj.is_absolute():
+            path = str(Path("/workspace") / path_obj)
+            path_obj = Path(path)
+
+        if not path_obj.exists():
+            return {"error": f"Directory not found: {path}"}
+
+        if not path_obj.is_dir():
+            return {"error": f"Path is not a directory: {path}"}
+
+        cmd = f"find '{path}' -type f -o -type d | head -500" if recursive else f"ls -1a '{path}'"
+
+        exit_code, stdout, stderr = run_shell_cmd(cmd)
+
+        if exit_code != 0:
+            return {"error": f"Error listing directory: {stderr}"}
+
+        items = stdout.strip().split("\n") if stdout.strip() else []
+
+        files = []
+        dirs = []
+
+        for item in items:
+            item_path = item if recursive else str(Path(path) / item)
+            item_path_obj = Path(item_path)
+
+            if item_path_obj.is_file():
+                files.append(item)
+            elif item_path_obj.is_dir():
+                dirs.append(item)
+
+        return {
+            "files": sorted(files),
+            "directories": sorted(dirs),
+            "total_files": len(files),
+            "total_dirs": len(dirs),
+            "path": path,
+            "recursive": recursive,
+        }
+
+    except (OSError, ValueError) as e:
+        return {"error": f"Error listing directory: {e!s}"}
+
+
+@register_tool
+def search_files(
+    path: str,
+    regex: str,
+    file_pattern: str = "*",
+) -> dict[str, Any]:
+    try:
+        path_obj = Path(path)
+        if not path_obj.is_absolute():
+            path = str(Path("/workspace") / path_obj)
+
+        if not Path(path).exists():
+            return {"error": f"Directory not found: {path}"}
+
+        escaped_regex = regex.replace("'", "'\"'\"'")
+
+        cmd = f"rg --line-number --glob '{file_pattern}' '{escaped_regex}' '{path}'"
+
+        exit_code, stdout, stderr = run_shell_cmd(cmd)
+
+        if exit_code not in {0, 1}:
+            return {"error": f"Error searching files: {stderr}"}
+        return {"output": stdout if stdout else "No matches found"}
+
+    except (OSError, ValueError) as e:
+        return {"error": f"Error searching files: {e!s}"}
+
+
+# ruff: noqa: TRY300

strix/tools/file_edit/file_edit_actions_schema.xml

@@ -0,0 +1,128 @@
+<tools>
+  <tool name="list_files">
+    <description>List files and directories within the specified directory.</description>
+    <parameters>
+      <parameter name="path" type="string" required="true">
+        <description>Directory path to list</description>
+      </parameter>
+      <parameter name="recursive" type="boolean" required="false">
+        <description>Whether to list files recursively</description>
+      </parameter>
+    </parameters>
+    <returns type="Dict[str, Any]">
+      <description>Response containing: - files: List of files and directories - total_files: Total number of files found - total_dirs: Total number of directories found</description>
+    </returns>
+    <notes>
+  - Lists contents alphabetically
+  - Returns maximum 500 results to avoid overwhelming output
+    </notes>
+    <examples>
+  # List directory contents
+  <function=list_files>
+  <parameter=path>/home/user/project/src</parameter>
+  </function>
+
+  # Recursive listing
+  <function=list_files>
+  <parameter=path>/home/user/project/src</parameter>
+  <parameter=recursive>true</parameter>
+  </function>
+    </examples>
+  </tool>
+  <tool name="search_files">
+    <description>Perform a regex search across files in a directory.</description>
+    <parameters>
+      <parameter name="path" type="string" required="true">
+        <description>Directory path to search</description>
+      </parameter>
+      <parameter name="regex" type="string" required="true">
+        <description>Regular expression pattern to search for</description>
+      </parameter>
+      <parameter name="file_pattern" type="string" required="false">
+        <description>File pattern to filter (e.g., "*.py", "*.js")</description>
+      </parameter>
+    </parameters>
+    <returns type="Dict[str, Any]">
+      <description>Response containing: - output: The search results as a string</description>
+    </returns>
+    <notes>
+  - Searches recursively through subdirectories
+  - Uses ripgrep for fast searching
+    </notes>
+    <examples>
+  # Search Python files for a pattern
+  <function=search_files>
+  <parameter=path>/home/user/project/src</parameter>
+  <parameter=regex>def\s+process_data</parameter>
+  <parameter=file_pattern>*.py</parameter>
+  </function>
+    </examples>
+  </tool>
+  <tool name="str_replace_editor">
+    <description>A text editor tool for viewing, creating and editing files.</description>
+    <parameters>
+      <parameter name="command" type="string" required="true">
+        <description>Editor command to execute</description>
+      </parameter>
+      <parameter name="path" type="string" required="true">
+        <description>Path to the file to edit</description>
+      </parameter>
+      <parameter name="file_text" type="string" required="false">
+        <description>Required parameter of create command, with the content of the file to be created</description>
+      </parameter>
+      <parameter name="view_range" type="string" required="false">
+        <description>Optional parameter of view command when path points to a file. If none is given, the full file is shown. If provided, the file will be shown in the indicated line number range, e.g. [11, 12] will show lines 11 and 12. Indexing at 1 to start. Setting [start_line, -1] shows all lines from start_line to the end of the file</description>
+      </parameter>
+      <parameter name="old_str" type="string" required="false">
+        <description>Required parameter of str_replace command containing the string in path to replace</description>
+      </parameter>
+      <parameter name="new_str" type="string" required="false">
+        <description>Optional parameter of str_replace command containing the new string (if not given, no string will be added). Required parameter of insert command containing the string to insert</description>
+      </parameter>
+      <parameter name="insert_line" type="string" required="false">
+        <description>Required parameter of insert command. The new_str will be inserted AFTER the line insert_line of path</description>
+      </parameter>
+    </parameters>
+    <returns type="Dict[str, Any]">
+      <description>Response containing the result of the operation</description>
+    </returns>
+    <notes>
+  Command details:
+  - view: Show file contents, optionally with line range
+  - create: Create a new file with given content
+  - str_replace: Replace old_str with new_str in file
+  - insert: Insert new_str after the specified line number
+  - undo_edit: Revert the last edit made to the file
+    </notes>
+    <examples>
+  # View a file
+  <function=str_replace_editor>
+  <parameter=command>view</parameter>
+  <parameter=path>/home/user/project/file.py</parameter>
+  </function>
+
+  # Create a file
+  <function=str_replace_editor>
+  <parameter=command>create</parameter>
+  <parameter=path>/home/user/project/new_file.py</parameter>
+  <parameter=file_text>print("Hello World")</parameter>
+  </function>
+
+  # Replace text in file
+  <function=str_replace_editor>
+  <parameter=command>str_replace</parameter>
+  <parameter=path>/home/user/project/file.py</parameter>
+  <parameter=old_str>old_function()</parameter>
+  <parameter=new_str>new_function()</parameter>
+  </function>
+
+  # Insert text after line 10
+  <function=str_replace_editor>
+  <parameter=command>insert</parameter>
+  <parameter=path>/home/user/project/file.py</parameter>
+  <parameter=insert_line>10</parameter>
+  <parameter=new_str>print("Inserted line")</parameter>
+  </function>
+    </examples>
+  </tool>
+</tools>

strix/tools/finish/__init__.py

@@ -0,0 +1,4 @@
+from .finish_actions import finish_scan
+
+
+__all__ = ["finish_scan"]

strix/tools/finish/finish_actions.py

@@ -0,0 +1,167 @@
+from typing import Any
+
+from strix.tools.registry import register_tool
+
+
+def _validate_root_agent(agent_state: Any) -> dict[str, Any] | None:
+    if (
+        agent_state is not None
+        and hasattr(agent_state, "parent_id")
+        and agent_state.parent_id is not None
+    ):
+        return {
+            "success": False,
+            "message": (
+                "This tool can only be used by the root/main agent. "
+                "Subagents must use agent_finish instead."
+            ),
+        }
+    return None
+
+
+def _validate_content(content: str) -> dict[str, Any] | None:
+    if not content or not content.strip():
+        return {"success": False, "message": "Content cannot be empty"}
+    return None
+
+
+def _check_active_agents() -> dict[str, Any] | None:
+    try:
+        from strix.tools.agents_graph.agents_graph_actions import _agent_graph
+
+        running_agents = []
+        stopping_agents = []
+
+        for agent_id, node in _agent_graph.get("nodes", {}).items():
+            status = node.get("status", "")
+            if status == "running":
+                running_agents.append(
+                    {
+                        "id": agent_id,
+                        "name": node.get("name", "Unknown"),
+                        "task": node.get("task", "No task description"),
+                    }
+                )
+            elif status == "stopping":
+                stopping_agents.append(
+                    {
+                        "id": agent_id,
+                        "name": node.get("name", "Unknown"),
+                    }
+                )
+
+        if running_agents or stopping_agents:
+            message_parts = ["Cannot finish scan while agents are still active:"]
+
+            if running_agents:
+                message_parts.append("\n\nRunning agents:")
+                message_parts.extend(
+                    [
+                        f"  - {agent['name']} ({agent['id']}): {agent['task']}"
+                        for agent in running_agents
+                    ]
+                )
+
+            if stopping_agents:
+                message_parts.append("\n\nStopping agents:")
+                message_parts.extend(
+                    [f"  - {agent['name']} ({agent['id']})" for agent in stopping_agents]
+                )
+
+            message_parts.extend(
+                [
+                    "\n\nSuggested actions:",
+                    "1. Use wait_for_message to wait for all agents to complete",
+                    "2. Send messages to agents asking them to finish if urgent",
+                    "3. Use view_agent_graph to monitor agent status",
+                ]
+            )
+
+            return {
+                "success": False,
+                "message": "\n".join(message_parts),
+                "active_agents": {
+                    "running": len(running_agents),
+                    "stopping": len(stopping_agents),
+                    "details": {
+                        "running": running_agents,
+                        "stopping": stopping_agents,
+                    },
+                },
+            }
+
+    except ImportError:
+        import logging
+
+        logging.warning("Could not check agent graph status - agents_graph module unavailable")
+
+    return None
+
+
+def _finalize_with_tracer(content: str, success: bool) -> dict[str, Any]:
+    try:
+        from strix.cli.tracer import get_global_tracer
+
+        tracer = get_global_tracer()
+        if tracer:
+            tracer.set_final_scan_result(
+                content=content.strip(),
+                success=success,
+            )
+
+            return {
+                "success": True,
+                "scan_completed": True,
+                "message": "Scan completed successfully"
+                if success
+                else "Scan completed with errors",
+                "vulnerabilities_found": len(tracer.vulnerability_reports),
+            }
+
+        import logging
+
+        logging.warning("Global tracer not available - final scan result not stored")
+
+        return {  # noqa: TRY300
+            "success": True,
+            "scan_completed": True,
+            "message": "Scan completed successfully (not persisted)"
+            if success
+            else "Scan completed with errors (not persisted)",
+            "warning": "Final result could not be persisted - tracer unavailable",
+        }
+
+    except ImportError:
+        return {
+            "success": True,
+            "scan_completed": True,
+            "message": "Scan completed successfully (not persisted)"
+            if success
+            else "Scan completed with errors (not persisted)",
+            "warning": "Final result could not be persisted - tracer module unavailable",
+        }
+
+
+@register_tool(sandbox_execution=False)
+def finish_scan(
+    content: str,
+    success: bool = True,
+    agent_state: Any = None,
+) -> dict[str, Any]:
+    try:
+        validation_error = _validate_root_agent(agent_state)
+        if validation_error:
+            return validation_error
+
+        validation_error = _validate_content(content)
+        if validation_error:
+            return validation_error
+
+        active_agents_error = _check_active_agents()
+        if active_agents_error:
+            return active_agents_error
+
+        return _finalize_with_tracer(content, success)
+
+    except (ValueError, TypeError, KeyError) as e:
+        return {"success": False, "message": f"Failed to complete scan: {e!s}"}

strix/tools/finish/finish_actions_schema.xml

@@ -0,0 +1,45 @@
+<tools>
+  <tool name="finish_scan">
+    <description>Complete the main security scan and generate final report.
+
+IMPORTANT: This tool can ONLY be used by the root/main agent.
+Subagents must use agent_finish from agents_graph tool instead.
+
+IMPORTANT: This tool will NOT allow finishing if any agents are still running or stopping.
+You must wait for all agents to complete before using this tool.
+
+This tool MUST be called at the very end of the security assessment to:
+- Verify all agents have completed their tasks
+- Generate the final comprehensive scan report
+- Mark the entire scan as completed
+- Stop the agent from running
+
+Use this tool when:
+- You are the main/root agent conducting the security assessment
+- ALL subagents have completed their tasks (no agents are "running" or "stopping")
+- You have completed all testing phases
+- You are ready to conclude the entire security assessment
+
+IMPORTANT: Calling this tool multiple times will OVERWRITE any previous scan report.
+Make sure you include ALL findings and details in a single comprehensive report.
+
+If agents are still running, this tool will:
+- Show you which agents are still active
+- Suggest using wait_for_message to wait for completion
+- Suggest messaging agents if immediate completion is needed
+
+Put ALL details in the content - methodology, tools used, vulnerability counts, key findings, recommendations,
+compliance notes, risk assessments, next steps, etc. Be comprehensive and include everything relevant.</description>
+    <parameters>
+      <parameter name="content" type="string" required="true">
+        <description>Complete scan report including executive summary, methodology, findings, vulnerability details, recommendations, compliance notes, risk assessment, and conclusions. Include everything relevant to the assessment.</description>
+      </parameter>
+      <parameter name="success" type="boolean" required="false">
+        <description>Whether the scan completed successfully without critical errors</description>
+      </parameter>
+    </parameters>
+    <returns type="Dict[str, Any]">
+      <description>Response containing success status and completion message. If agents are still running, returns details about active agents and suggested actions.</description>
+    </returns>
+  </tool>
+</tools>

strix/tools/notes/__init__.py

@@ -0,0 +1,14 @@
+from .notes_actions import (
+    create_note,
+    delete_note,
+    list_notes,
+    update_note,
+)
+
+
+__all__ = [
+    "create_note",
+    "delete_note",
+    "list_notes",
+    "update_note",
+]

strix/tools/notes/notes_actions.py

@@ -0,0 +1,191 @@
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+from strix.tools.registry import register_tool
+
+
+_notes_storage: dict[str, dict[str, Any]] = {}
+
+
+def _filter_notes(
+    category: str | None = None,
+    tags: list[str] | None = None,
+    priority: str | None = None,
+    search_query: str | None = None,
+) -> list[dict[str, Any]]:
+    filtered_notes = []
+
+    for note_id, note in _notes_storage.items():
+        if category and note.get("category") != category:
+            continue
+
+        if priority and note.get("priority") != priority:
+            continue
+
+        if tags:
+            note_tags = note.get("tags", [])
+            if not any(tag in note_tags for tag in tags):
+                continue
+
+        if search_query:
+            search_lower = search_query.lower()
+            title_match = search_lower in note.get("title", "").lower()
+            content_match = search_lower in note.get("content", "").lower()
+            if not (title_match or content_match):
+                continue
+
+        note_with_id = note.copy()
+        note_with_id["note_id"] = note_id
+        filtered_notes.append(note_with_id)
+
+    filtered_notes.sort(key=lambda x: x.get("created_at", ""), reverse=True)
+    return filtered_notes
+
+
+@register_tool
+def create_note(
+    title: str,
+    content: str,
+    category: str = "general",
+    tags: list[str] | None = None,
+    priority: str = "normal",
+) -> dict[str, Any]:
+    try:
+        if not title or not title.strip():
+            return {"success": False, "error": "Title cannot be empty", "note_id": None}
+
+        if not content or not content.strip():
+            return {"success": False, "error": "Content cannot be empty", "note_id": None}
+
+        valid_categories = ["general", "findings", "methodology", "todo", "questions", "plan"]
+        if category not in valid_categories:
+            return {
+                "success": False,
+                "error": f"Invalid category. Must be one of: {', '.join(valid_categories)}",
+                "note_id": None,
+            }
+
+        valid_priorities = ["low", "normal", "high", "urgent"]
+        if priority not in valid_priorities:
+            return {
+                "success": False,
+                "error": f"Invalid priority. Must be one of: {', '.join(valid_priorities)}",
+                "note_id": None,
+            }
+
+        note_id = str(uuid.uuid4())[:5]
+        timestamp = datetime.now(UTC).isoformat()
+
+        note = {
+            "title": title.strip(),
+            "content": content.strip(),
+            "category": category,
+            "tags": tags or [],
+            "priority": priority,
+            "created_at": timestamp,
+            "updated_at": timestamp,
+        }
+
+        _notes_storage[note_id] = note
+
+    except (ValueError, TypeError) as e:
+        return {"success": False, "error": f"Failed to create note: {e}", "note_id": None}
+    else:
+        return {
+            "success": True,
+            "note_id": note_id,
+            "message": f"Note '{title}' created successfully",
+        }
+
+
+@register_tool
+def list_notes(
+    category: str | None = None,
+    tags: list[str] | None = None,
+    priority: str | None = None,
+    search: str | None = None,
+) -> dict[str, Any]:
+    try:
+        filtered_notes = _filter_notes(
+            category=category, tags=tags, priority=priority, search_query=search
+        )
+
+        return {
+            "success": True,
+            "notes": filtered_notes,
+            "total_count": len(filtered_notes),
+        }
+
+    except (ValueError, TypeError) as e:
+        return {
+            "success": False,
+            "error": f"Failed to list notes: {e}",
+            "notes": [],
+            "total_count": 0,
+        }
+
+
+@register_tool
+def update_note(
+    note_id: str,
+    title: str | None = None,
+    content: str | None = None,
+    tags: list[str] | None = None,
+    priority: str | None = None,
+) -> dict[str, Any]:
+    try:
+        if note_id not in _notes_storage:
+            return {"success": False, "error": f"Note with ID '{note_id}' not found"}
+
+        note = _notes_storage[note_id]
+
+        if title is not None:
+            if not title.strip():
+                return {"success": False, "error": "Title cannot be empty"}
+            note["title"] = title.strip()
+
+        if content is not None:
+            if not content.strip():
+                return {"success": False, "error": "Content cannot be empty"}
+            note["content"] = content.strip()
+
+        if tags is not None:
+            note["tags"] = tags
+
+        if priority is not None:
+            valid_priorities = ["low", "normal", "high", "urgent"]
+            if priority not in valid_priorities:
+                return {
+                    "success": False,
+                    "error": f"Invalid priority. Must be one of: {', '.join(valid_priorities)}",
+                }
+            note["priority"] = priority
+
+        note["updated_at"] = datetime.now(UTC).isoformat()
+
+        return {
+            "success": True,
+            "message": f"Note '{note['title']}' updated successfully",
+        }
+
+    except (ValueError, TypeError) as e:
+        return {"success": False, "error": f"Failed to update note: {e}"}
+
+
+@register_tool
+def delete_note(note_id: str) -> dict[str, Any]:
+    try:
+        if note_id not in _notes_storage:
+            return {"success": False, "error": f"Note with ID '{note_id}' not found"}
+
+        note_title = _notes_storage[note_id]["title"]
+        del _notes_storage[note_id]
+
+    except (ValueError, TypeError) as e:
+        return {"success": False, "error": f"Failed to delete note: {e}"}
+    else:
+        return {
+            "success": True,
+            "message": f"Note '{note_title}' deleted successfully",
+        }