idun-agent-engine 0.3.8__py3-none-any.whl → 0.4.0__py3-none-any.whl

idun_platform_cli/tui/widgets/identity_widget.py

@@ -0,0 +1,234 @@
+"""Identity configuration widget."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.reactive import reactive
+from textual.widget import Widget
+from textual.widgets import DirectoryTree, Input, Markdown, OptionList, Static
+from textual.widgets.option_list import Option
+
+HELP_TEXT = """
+**Quick Guide**
+
+- **Name** : Name of your agent
+- **Framework** : LangGraph/ADK/Haystack
+- **Port** : Network port
+- **Graph** : Select .py file + variable
+
+[📚 Docs](https://idun-group.github.io/idun-agent-platform) | [💬 Help](https://discord.gg/KCZ6nW2jQe)
+"""
+
+
+class IdentityWidget(Widget):
+    full_definition = reactive("")
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.selected_file_path = ""
+
+    def compose(self) -> ComposeResult:
+        agent_info_section = Horizontal(
+            classes="section section-split agent-info-section"
+        )
+        agent_info_section.border_title = "Agent Information"
+
+        with agent_info_section:
+            identity_container = Vertical(classes="form-fields-container")
+            identity_container.border_title = "Identity"
+
+            with identity_container:
+                with Horizontal(classes="field-row"):
+                    yield Static("Name:", classes="field-label")
+                    yield Input(
+                        value="my-agent", classes="field-input", id="name_input"
+                    )
+
+                with Horizontal(classes="field-row framework-row"):
+                    yield Static("Framework:", classes="field-label")
+                    yield OptionList(
+                        Option("LANGGRAPH", id="LANGGRAPH"),
+                        Option("ADK", id="ADK"),
+                        Option("HAYSTACK", id="HAYSTACK"),
+                        classes="field-input",
+                        id="framework_select",
+                    )
+
+                with Horizontal(classes="field-row"):
+                    yield Static("Port:", classes="field-label")
+                    yield Input(value="8008", classes="field-input", id="port_input")
+
+                yield Static("", classes="error-message", id="identity_error")
+
+            with Vertical(classes="info-panel"):
+                yield Markdown(HELP_TEXT, classes="help-markdown")
+
+        graph_section = Vertical(classes="graph-definition-section")
+        graph_section.border_title = "Graph Definition"
+
+        with graph_section:
+            with Horizontal(classes="graph-def-row"):
+                tree_container = Vertical(classes="tree-container")
+                tree_container.border_title = "Select Python File"
+                with tree_container:
+                    yield DirectoryTree(".", id="file_tree")
+
+                var_container = Vertical(classes="var-container")
+                var_container.border_title = "Select Variable"
+                with var_container:
+                    yield OptionList(
+                        classes="var-list",
+                        id="variable_list",
+                    )
+
+            path_container = Vertical(classes="path-display-container")
+            path_container.border_title = "Agent Path"
+            with path_container:
+                yield Static(
+                    "Select file and variable",
+                    classes="full-definition-display",
+                    id="full_definition",
+                )
+
+    def on_mount(self) -> None:
+        option_list = self.query_one("#framework_select", OptionList)
+        option_list.highlighted = 0
+        self._update_section_labels()
+
+    def watch_full_definition(self, value: str) -> None:
+        self.query_one("#full_definition", Static).update(
+            value if value else "Select file and variable"
+        )
+
+    def on_directory_tree_file_selected(
+        self, event: DirectoryTree.FileSelected
+    ) -> None:
+        selected_path = str(event.path)
+
+        if selected_path.endswith(".py"):
+            self.selected_file_path = selected_path
+            self._parse_python_file(selected_path)
+            self._update_full_definition()
+        else:
+            self.app.notify("Please select a Python file", severity="warning")
+
+    def _parse_python_file(self, file_path: str) -> None:
+        import ast
+
+        try:
+            with open(file_path, "r") as f:
+                tree = ast.parse(f.read())
+
+            variables = []
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Assign):
+                    for target in node.targets:
+                        if isinstance(target, ast.Name):
+                            variables.append(target.id)
+
+            var_list = self.query_one("#variable_list", OptionList)
+            var_list.clear_options()
+
+            if variables:
+                for var in variables:
+                    var_list.add_option(Option(var, id=var))
+                var_list.highlighted = 0
+            else:
+                var_list.add_option(Option("No variables found", id="none"))
+
+        except Exception as e:
+            self.app.notify(f"Error parsing file: {str(e)}", severity="error")
+
+    def on_option_list_option_highlighted(
+        self, event: OptionList.OptionHighlighted
+    ) -> None:
+        if event.option_list.id == "variable_list":
+            self._update_full_definition()
+        elif event.option_list.id == "framework_select":
+            self._update_section_labels()
+
+    def _update_section_labels(self) -> None:
+        framework_select = self.query_one("#framework_select", OptionList)
+        if framework_select.highlighted is not None:
+            framework_option = framework_select.get_option_at_index(framework_select.highlighted)
+            framework = str(framework_option.id)
+
+            graph_section = self.query_one(".graph-definition-section", Vertical)
+
+            if framework == "LANGGRAPH":
+                graph_section.border_title = "Graph Definition"
+            elif framework == "ADK":
+                graph_section.border_title = "Agent Definition"
+            elif framework == "HAYSTACK":
+                graph_section.border_title = "Pipeline Definition"
+
+    def _update_full_definition(self) -> None:
+        if not self.selected_file_path:
+            self.full_definition = ""
+            return
+
+        var_list = self.query_one("#variable_list", OptionList)
+        var_index = var_list.highlighted
+
+        if var_index is not None and var_list.option_count > 0:
+            try:
+                variable_option = var_list.get_option_at_index(var_index)
+                variable_name = str(variable_option.id)
+                self.full_definition = f"{self.selected_file_path}:{variable_name}"
+            except:
+                self.full_definition = self.selected_file_path
+        else:
+            self.full_definition = self.selected_file_path
+
+    def validate(self) -> bool:
+        self.query_one("#identity_error", Static).update("")
+
+        port = self.query_one("#port_input", Input).value
+        name = self.query_one("#name_input", Input).value
+
+        if not port or not name:
+            self.query_one("#identity_error", Static).update(
+                "Agent name or port is empty!"
+            )
+            self.app.notify("Agent name and port are required!", severity="error")
+            return False
+
+        var_list = self.query_one("#variable_list", OptionList)
+        var_index = var_list.highlighted
+
+        if not self.selected_file_path or var_index is None:
+            self.query_one("#identity_error", Static).update(
+                "Please select a file and variable"
+            )
+            self.app.notify("Graph definition incomplete!", severity="error")
+            return False
+
+        return True
+
+    def get_data(self) -> dict:
+        var_list = self.query_one("#variable_list", OptionList)
+        var_index = var_list.highlighted
+
+        variable_name = ""
+        if var_index is not None and var_list.option_count > 0:
+            variable_option = var_list.get_option_at_index(var_index)
+            variable_name = str(variable_option.id)
+
+        graph_definition = (
+            f"{self.selected_file_path}:{variable_name}"
+            if self.selected_file_path
+            else ""
+        )
+
+        option_list = self.query_one("#framework_select", OptionList)
+        index = option_list.highlighted
+        framework = "LANGGRAPH"
+        if index is not None:
+            selected_option = option_list.get_option_at_index(index)
+            framework = str(selected_option.id)
+
+        return {
+            "name": self.query_one("#name_input", Input).value,
+            "framework": framework,
+            "port": self.query_one("#port_input", Input).value,
+            "graph_definition": graph_definition,
+        }

idun_platform_cli/tui/widgets/mcps_widget.py

@@ -0,0 +1,230 @@
+"""MCPs configuration widget."""
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Static, Input, Button, RadioSet, RadioButton, TextArea, OptionList
+from textual.widget import Widget
+from textual.widgets.option_list import Option
+
+
+MCP_TEMPLATES = {
+    "time": {
+        "name": "time-reference",
+        "transport": "stdio",
+        "command": "docker",
+        "args": ["run", "-i", "--rm", "mcp/time"],
+    },
+}
+
+
+class MCPsWidget(Widget):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.mcp_servers = []
+        self.next_server_id = 0
+
+    def on_mount(self) -> None:
+        template_selector = self.query_one("#template_selector", OptionList)
+        if template_selector.option_count > 0:
+            template_selector.highlighted = 0
+
+    def compose(self) -> ComposeResult:
+        templates_section = Vertical(classes="mcps-templates-section")
+        templates_section.border_title = "MCP Templates"
+        templates_row = Horizontal(classes="templates-row")
+        templates_row.compose_add_child(Static("Select template:", classes="mcp-label"))
+        option_list = OptionList(id="template_selector", classes="template-selector")
+        for template_name in MCP_TEMPLATES.keys():
+            option_list.add_option(Option(template_name.title(), id=template_name))
+        templates_row.compose_add_child(option_list)
+        templates_row.compose_add_child(Button("Add from Template", id="add_from_template_button", classes="add-template-btn"))
+        templates_section.compose_add_child(templates_row)
+        yield templates_section
+
+        yield Button("+ Add Custom MCP Server", id="add_custom_mcp_button", classes="add-custom-btn")
+
+        yield Vertical(id="mcps_container", classes="mcps-container")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        button_id = event.button.id
+
+        if button_id == "add_custom_mcp_button":
+            self._add_mcp_server()
+        elif button_id == "add_from_template_button":
+            self._add_from_template()
+        elif button_id and str(button_id).startswith("remove_mcp_"):
+            index = int(str(button_id).replace("remove_mcp_", ""))
+            self._remove_mcp_server(index)
+
+    def on_radio_set_changed(self, event: RadioSet.Changed) -> None:
+        radio_id = event.radio_set.id
+        if radio_id and str(radio_id).startswith("mcp_transport_"):
+            index = int(str(radio_id).replace("mcp_transport_", ""))
+            if event.pressed:
+                transport = str(event.pressed.id)
+                self._update_transport_fields(index, transport)
+
+    def _add_from_template(self) -> None:
+        template_selector = self.query_one("#template_selector", OptionList)
+        if template_selector.highlighted is not None:
+            option_id = template_selector.get_option_at_index(template_selector.highlighted).id
+            if option_id and str(option_id) in MCP_TEMPLATES:
+                template_data = MCP_TEMPLATES[str(option_id)].copy()
+                self._add_mcp_server(template_data)
+        else:
+            self.app.notify("Please select a template first", severity="warning")
+
+    def _add_mcp_server(self, template_data: dict = None) -> None:
+        server_id = self.next_server_id
+        self.next_server_id += 1
+        self.mcp_servers.append(server_id)
+
+        card = self._create_mcp_card(server_id, template_data)
+        container = self.query_one("#mcps_container", Vertical)
+        container.mount(card)
+
+    def _remove_mcp_server(self, index: int) -> None:
+        if index in self.mcp_servers:
+            self.mcp_servers.remove(index)
+            card = self.query_one(f"#mcp_card_{index}")
+            card.remove()
+
+    def _create_mcp_card(self, index: int, template_data: dict = None) -> Vertical:
+        card = Vertical(id=f"mcp_card_{index}", classes="mcp-card")
+        card.border_title = f"MCP Server {index + 1}"
+
+        header = Horizontal(classes="mcp-header")
+        name_value = template_data.get("name", "") if template_data else ""
+        header.compose_add_child(Static(name_value or f"Server {index + 1}", id=f"mcp_name_display_{index}", classes="mcp-name-display"))
+        header.compose_add_child(Button("Remove", id=f"remove_mcp_{index}", classes="remove-mcp-btn"))
+        card.compose_add_child(header)
+
+        name_row = Horizontal(classes="mcp-field-row")
+        name_row.compose_add_child(Static("Name:", classes="mcp-label"))
+        name_row.compose_add_child(Input(value=name_value, placeholder="server-name", id=f"mcp_name_{index}", classes="mcp-input"))
+        card.compose_add_child(name_row)
+
+        transport_row = Horizontal(classes="mcp-field-row")
+        transport_row.compose_add_child(Static("Transport:", classes="mcp-label"))
+        radio_set = RadioSet(id=f"mcp_transport_{index}")
+
+        transport_value = template_data.get("transport", "streamable_http") if template_data else "streamable_http"
+        radio_set.compose_add_child(RadioButton("stdio", id="stdio", value=(transport_value == "stdio")))
+        radio_set.compose_add_child(RadioButton("sse", id="sse", value=(transport_value == "sse")))
+        radio_set.compose_add_child(RadioButton("streamable_http", id="streamable_http", value=(transport_value == "streamable_http")))
+        radio_set.compose_add_child(RadioButton("websocket", id="websocket", value=(transport_value == "websocket")))
+        transport_row.compose_add_child(radio_set)
+        card.compose_add_child(transport_row)
+
+        http_fields = Vertical(id=f"mcp_http_fields_{index}", classes="http-fields-container")
+        http_fields.border_title = "HTTP Configuration"
+
+        url_row = Horizontal(classes="mcp-field-row")
+        url_row.compose_add_child(Static("URL:", classes="mcp-label"))
+        url_value = template_data.get("url", "") if template_data else ""
+        url_row.compose_add_child(Input(value=url_value, placeholder="https://api.example.com/mcp", id=f"mcp_url_{index}", classes="mcp-input"))
+        http_fields.compose_add_child(url_row)
+
+        headers_row = Horizontal(classes="mcp-field-row")
+        headers_row.compose_add_child(Static("Headers (JSON):", classes="mcp-label"))
+        headers_value = template_data.get("headers", "") if template_data else ""
+        headers_row.compose_add_child(TextArea(text=str(headers_value) if headers_value else "", id=f"mcp_headers_{index}", classes="mcp-textarea"))
+        http_fields.compose_add_child(headers_row)
+
+        http_fields.display = transport_value in ["sse", "streamable_http", "websocket"]
+        card.compose_add_child(http_fields)
+
+        stdio_fields = Vertical(id=f"mcp_stdio_fields_{index}", classes="stdio-fields-container")
+        stdio_fields.border_title = "Stdio Configuration"
+
+        command_row = Horizontal(classes="mcp-field-row")
+        command_row.compose_add_child(Static("Command:", classes="mcp-label"))
+        command_value = template_data.get("command", "") if template_data else ""
+        command_row.compose_add_child(Input(value=command_value, placeholder="npx", id=f"mcp_command_{index}", classes="mcp-input"))
+        stdio_fields.compose_add_child(command_row)
+
+        args_row = Horizontal(classes="mcp-field-row")
+        args_row.compose_add_child(Static("Args (one per line):", classes="mcp-label"))
+        args_value = ""
+        if template_data and "args" in template_data:
+            args_list = template_data["args"]
+            if isinstance(args_list, list):
+                args_value = "\n".join(args_list)
+        args_textarea = TextArea(text=args_value, id=f"mcp_args_{index}", classes="mcp-textarea")
+        args_textarea.placeholder = "run\n-i\n--rm"
+        args_row.compose_add_child(args_textarea)
+        stdio_fields.compose_add_child(args_row)
+
+        env_row = Horizontal(classes="mcp-field-row")
+        env_row.compose_add_child(Static("Env Vars (JSON):", classes="mcp-label"))
+        env_value = ""
+        if template_data and "env" in template_data:
+            import json
+            env_value = json.dumps(template_data["env"], indent=2)
+        env_row.compose_add_child(TextArea(text=env_value, id=f"mcp_env_{index}", classes="mcp-textarea"))
+        stdio_fields.compose_add_child(env_row)
+
+        stdio_fields.display = transport_value == "stdio"
+        card.compose_add_child(stdio_fields)
+
+        return card
+
+    def _update_transport_fields(self, index: int, transport: str) -> None:
+        http_fields = self.query_one(f"#mcp_http_fields_{index}")
+        stdio_fields = self.query_one(f"#mcp_stdio_fields_{index}")
+
+        if transport in ["sse", "streamable_http", "websocket"]:
+            http_fields.display = True
+            stdio_fields.display = False
+        elif transport == "stdio":
+            http_fields.display = False
+            stdio_fields.display = True
+
+    def get_data(self) -> list[dict] | None:
+        servers_data = []
+
+        for server_id in self.mcp_servers:
+            try:
+                name_input = self.query_one(f"#mcp_name_{server_id}", Input)
+                name = name_input.value
+
+                if not name:
+                    self.app.notify(f"Server {server_id + 1}: Name is required", severity="error")
+                    return None
+
+                radio_set = self.query_one(f"#mcp_transport_{server_id}", RadioSet)
+                transport = "streamable_http"
+                if radio_set.pressed_button:
+                    transport = str(radio_set.pressed_button.id)
+
+                server_config = {
+                    "name": name,
+                    "transport": transport,
+                }
+
+                if transport in ["sse", "streamable_http", "websocket"]:
+                    url_input = self.query_one(f"#mcp_url_{server_id}", Input)
+                    server_config["url"] = url_input.value
+
+                    headers_textarea = self.query_one(f"#mcp_headers_{server_id}", TextArea)
+                    if headers_textarea.text.strip():
+                        server_config["headers"] = headers_textarea.text.strip()
+
+                elif transport == "stdio":
+                    command_input = self.query_one(f"#mcp_command_{server_id}", Input)
+                    server_config["command"] = command_input.value
+
+                    args_textarea = self.query_one(f"#mcp_args_{server_id}", TextArea)
+                    server_config["args"] = args_textarea.text
+
+                    env_textarea = self.query_one(f"#mcp_env_{server_id}", TextArea)
+                    if env_textarea.text.strip():
+                        server_config["env"] = env_textarea.text.strip()
+
+                servers_data.append(server_config)
+
+            except Exception as e:
+                self.app.notify(f"Error reading server {server_id + 1}: {str(e)}", severity="error")
+                return None
+
+        return servers_data