jvcli 2.0.15__tar.gz → 2.0.17__tar.gz

{jvcli-2.0.15/jvcli.egg-info → jvcli-2.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jvcli
-Version: 2.0.15
+Version: 2.0.17
 Summary: CLI tool for Jivas Package Repository
 Home-page: https://github.com/TrueSelph/jvcli
 Author: TrueSelph Inc.
@@ -12,7 +12,7 @@ Requires-Dist: click>=8.1.8
 Requires-Dist: requests>=2.32.3
 Requires-Dist: packaging>=24.2
 Requires-Dist: pyaml>=25.1.0
-Requires-Dist: jac-cloud>=0.1.19
+Requires-Dist: jac-cloud==0.1.20
 Requires-Dist: streamlit>=1.42.0
 Requires-Dist: streamlit-elements>=0.1.0
 Requires-Dist: streamlit-router>=0.1.8

{jvcli-2.0.15 → jvcli-2.0.17}/jvcli/__init__.py

@@ -4,5 +4,5 @@ jvcli package initialization.
 This package provides the CLI tool for Jivas Package Repository.
 """
 
-__version__ = "2.0.15"
+__version__ = "2.0.17"
 __supported__jivas__versions__ = ["2.0.0"]

{jvcli-2.0.15 → jvcli-2.0.17}/jvcli/client/app.py

@@ -8,10 +8,14 @@ from streamlit_router import StreamlitRouter
 
 from jvcli.client.lib.page import Page
 from jvcli.client.lib.utils import call_list_actions, call_list_agents, load_function
-from jvcli.client.pages import analytics_page, chat_page, dashboard_page, graph_page
-
-JIVAS_URL = os.environ.get("JIVAS_URL", "http://localhost:8000")
-
+from jvcli.client.pages import (
+    action_dashboard_page,
+    analytics_page,
+    chat_page,
+    graph_page,
+)
+
+JIVAS_BASE_URL = os.environ.get("JIVAS_BASE_URL", "http://localhost:8000")
 JIVAS_STUDIO_URL = os.environ.get("JIVAS_STUDIO_URL", "http://localhost:8989")
 
 
@@ -24,7 +28,7 @@ def handle_agent_selection() -> None:
 
 def login_form() -> None:
     """Render the login form and handle login logic."""
-    login_url = f"{JIVAS_URL}/user/login"
+    login_url = f"{JIVAS_BASE_URL}/user/login"
 
     if os.environ.get("JIVAS_ENVIRONMENT") == "development":
         email = os.environ.get("JIVAS_USER", "admin@jivas.com")
@@ -67,7 +71,6 @@ def main() -> None:
     for key in [
         "messages",
         "session_id",
-        "EXPIRATION",
         "agents",
         "actions_data",
         "TOKEN",
@@ -127,10 +130,14 @@ def main() -> None:
         with st.expander("Menu", True):
             Page(router).item(analytics_page.render, "Dashboard", "/").st_button()
             Page(router).item(chat_page.render, "Chat", "/chat").st_button()
-            Page(router).item(dashboard_page.render, "Actions", "/actions").st_button()
+            Page(router).item(
+                action_dashboard_page.render, "Actions", "/actions"
+            ).st_button()
             Page(router).item(graph_page.render, "Graph", "/graph").st_button()
             st.button(
-                "Logout", on_click=dashboard_page.logout, use_container_width=True
+                "Logout",
+                on_click=action_dashboard_page.logout,
+                use_container_width=True,
             )
 
         with st.expander("Action Apps", False):

jvcli-2.0.17/jvcli/client/lib/utils.py

@@ -0,0 +1,310 @@
+"""This module contains utility functions for the JVCLI client."""
+
+import base64
+import json
+import os
+from importlib.util import module_from_spec, spec_from_file_location
+from io import BytesIO
+from typing import Any, Callable, Dict, List, Optional
+
+import requests
+import streamlit as st
+import yaml
+from PIL import Image
+
+JIVAS_BASE_URL = os.environ.get("JIVAS_BASE_URL", "http://localhost:8000")
+
+
+def load_function(file_path: str, function_name: str, **kwargs: Any) -> Callable:
+    """Dynamically loads and returns a function from a Python file, with optional keyword arguments."""
+
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"No file found at {file_path}")
+
+    # Get the module name from the file name
+    module_name = os.path.splitext(os.path.basename(file_path))[0]
+
+    # Load the module specification
+    spec = spec_from_file_location(module_name, file_path)
+    if spec is None:
+        raise ImportError(f"Could not load specification for module {module_name}")
+
+    # Create the module
+    module = module_from_spec(spec)
+    if spec.loader is None:
+        raise ImportError(f"Could not load module {module_name}")
+
+    # Execute the module
+    spec.loader.exec_module(module)
+
+    # Get the function
+    if not hasattr(module, function_name):
+        raise AttributeError(f"Function '{function_name}' not found in {file_path}")
+
+    func = getattr(module, function_name)
+
+    # Ensure the returned callable can accept any kwargs passed to it
+    def wrapped_func(*args: Any, **func_kwargs: Any) -> Any:
+        return func(*args, **{**kwargs, **func_kwargs})
+
+    return wrapped_func
+
+
+def call_api(
+    endpoint: str,
+    method: str = "POST",
+    headers: Optional[Dict] = None,
+    json_data: Optional[Dict] = None,
+    files: Optional[List] = None,
+    data: Optional[Dict] = None,
+) -> Optional[requests.Response]:
+    """Generic function to call an API endpoint."""
+
+    if not endpoint.startswith("http"):
+        endpoint = f"{JIVAS_BASE_URL}/{endpoint}"
+
+    ctx = get_user_info()  # Assumes a function that fetches user info
+
+    if ctx.get("token"):
+        try:
+            headers = headers or {}
+            headers["Authorization"] = f"Bearer {ctx['token']}"
+
+            response = requests.request(
+                method=method,
+                url=endpoint,
+                headers=headers,
+                json=json_data,
+                files=files,
+                data=data,
+            )
+
+            if response.status_code == 401:
+                st.session_state.EXPIRATION = ""
+                return None
+
+            return response
+
+        except Exception as e:
+            st.session_state.EXPIRATION = ""
+            st.write(e)
+
+    return None
+
+
+def call_action_walker_exec(
+    agent_id: str,
+    module_root: str,
+    walker: str,
+    args: Optional[Dict] = None,
+    files: Optional[List] = None,
+    headers: Optional[Dict] = None,
+) -> list:
+    """Call the API to execute a walker action for a given agent."""
+
+    endpoint = f"{JIVAS_BASE_URL}/action/walker"
+
+    # Create form data
+    data = {"agent_id": agent_id, "module_root": module_root, "walker": walker}
+
+    if args:
+        data["args"] = json.dumps(args)
+
+    file_list = []
+
+    if files:
+        for file in files:
+            file_list.append(("attachments", (file[0], file[1], file[2])))
+
+    response = call_api(endpoint, headers=headers, data=data, files=file_list)
+
+    if response and response.status_code == 200:
+        result = response.json()
+        return result if result else []
+
+    return []
+
+
+def call_healthcheck(agent_id: str, headers: Optional[Dict] = None) -> Optional[dict]:
+    """Call the API to check the health of an agent."""
+    endpoint = "walker/healthcheck"
+    json_data = {"agent_id": agent_id}
+    response = call_api(endpoint, headers=headers, json_data=json_data)
+
+    if response and response.status_code in [200, 501, 503]:
+        result = response.json()
+        reports = result.get("reports", [])
+        return reports[0] if reports else {}
+
+    return {}
+
+
+def call_list_agents(headers: Optional[Dict] = None) -> list:
+    """Call the API to list agents."""
+    endpoint = "walker/list_agents"
+    json_data = {"reporting": True}
+    response = call_api(endpoint, headers=headers, json_data=json_data)
+
+    if response and response.status_code == 200:
+        result = response.json()
+        reports = result.get("reports", [])
+        return [
+            {"id": agent.get("id", ""), "label": agent.get("name", "")}
+            for agent in reports
+        ]
+
+    return []
+
+
+def call_get_agent(agent_id: str, headers: Optional[Dict] = None) -> dict:
+    """Call the API to get details of a specific agent."""
+    endpoint = "walker/get_agent"
+    json_data = {"agent_id": agent_id}
+    response = call_api(endpoint, headers=headers, json_data=json_data)
+
+    if response and response.status_code == 200:
+        result = response.json()
+        reports = result.get("reports", [])
+        return reports[0] if reports else {}
+
+    return {}
+
+
+def call_list_actions(agent_id: str, headers: Optional[Dict] = None) -> list:
+    """Call the API to list actions for a given agent."""
+    endpoint = "walker/list_actions"
+    json_data = {"agent_id": agent_id}
+    response = call_api(endpoint, headers=headers, json_data=json_data)
+
+    if response and response.status_code == 200:
+        result = response.json()
+        reports = result.get("reports", [])
+        return reports[0] if reports else []
+
+    return []
+
+
+def call_get_action(
+    agent_id: str, action_id: str, headers: Optional[Dict] = None
+) -> dict:
+    """Call the API to get a specific action for a given agent."""
+    endpoint = "walker/get_action"
+    json_data = {"agent_id": agent_id, "action_id": action_id}
+    response = call_api(endpoint, headers=headers, json_data=json_data)
+
+    if response and response.status_code == 200:
+        result = response.json()
+        reports = result.get("reports", [])
+        return reports[0] if reports else {}
+
+    return {}
+
+
+def call_update_action(
+    agent_id: str, action_id: str, action_data: dict, headers: Optional[Dict] = None
+) -> dict:
+    """Call the API to update a specific action for a given agent."""
+    endpoint = "walker/update_action"
+    json_data = {
+        "agent_id": agent_id,
+        "action_id": action_id,
+        "action_data": action_data,
+    }
+    response = call_api(endpoint, headers=headers, json_data=json_data)
+
+    if response and response.status_code == 200:
+        result = response.json()
+        reports = result.get("reports", [])
+        return reports[0] if reports else {}
+
+    return {}
+
+
+def call_update_agent(
+    agent_id: str, agent_data: dict, headers: Optional[Dict] = None
+) -> dict:
+    """Call the API to update a specific agent."""
+    endpoint = "walker/update_agent"
+    json_data = {"agent_id": agent_id, "agent_data": agent_data}
+    response = call_api(endpoint, headers=headers, json_data=json_data)
+
+    if response and response.status_code == 200:
+        result = response.json()
+        reports = result.get("reports", [])
+        return reports[0] if reports else {}
+
+    return {}
+
+
+def call_import_agent(descriptor: str, headers: Optional[Dict] = None) -> list:
+    """Call the API to import an agent."""
+    endpoint = "walker/import_agent"
+    json_data = {"descriptor": descriptor}
+    response = call_api(endpoint, headers=headers, json_data=json_data)
+
+    if response and response.status_code == 200:
+        result = response.json()
+        reports = result.get("reports", [])
+        return reports[0] if reports else []
+
+    return []
+
+
+def get_user_info() -> dict:
+    """Get user information from the session state."""
+    return {
+        "root_id": st.session_state.get("ROOT_ID", ""),
+        "token": st.session_state.get("TOKEN", ""),
+        "expiration": st.session_state.get("EXPIRATION", ""),
+    }
+
+
+def decode_base64_image(base64_string: str) -> Image:
+    """Decode a base64 string into an image."""
+    # Decode the base64 string
+    image_data = base64.b64decode(base64_string)
+
+    # Create a bytes buffer from the decoded bytes
+    image_buffer = BytesIO(image_data)
+
+    # Open the image using PIL
+    return Image.open(image_buffer)
+
+
+class LongStringDumper(yaml.SafeDumper):
+    """Custom YAML dumper to handle long strings."""
+
+    def represent_scalar(
+        self, tag: str, value: str, style: Optional[str] = None
+    ) -> yaml.ScalarNode:
+        """Represent scalar values, using block style for long strings."""
+        # Replace any escape sequences to format the output as desired
+        if (
+            len(value) > 150 or "\n" in value
+        ):  # Adjust the threshold for long strings as needed
+            style = "|"
+            # converts all newline escapes to actual representations
+            value = "\n".join([line.rstrip() for line in value.split("\n")])
+        else:
+            # converts all newline escapes to actual representations
+            value = "\n".join([line.rstrip() for line in value.split("\n")]).rstrip()
+
+        return super().represent_scalar(tag, value, style)
+
+
+def jac_yaml_dumper(
+    data: Any,
+    indent: int = 2,
+    default_flow_style: bool = False,
+    allow_unicode: bool = True,
+    sort_keys: bool = False,
+) -> str:
+    """Dumps YAML data using LongStringDumper with customizable options."""
+    return yaml.dump(
+        data,
+        Dumper=LongStringDumper,
+        indent=indent,
+        default_flow_style=default_flow_style,
+        allow_unicode=allow_unicode,
+        sort_keys=sort_keys,
+    )

jvcli-2.0.15/jvcli/client/pages/dashboard_page.py → jvcli-2.0.17/jvcli/client/pages/action_dashboard_page.py

@@ -1,4 +1,4 @@
-"""Render the dashboard page of the jvclient with actions data."""
+"""Render the action_dashboard page of the jvclient with actions data."""
 
 import streamlit as st
 from streamlit_elements import dashboard, elements, mui
@@ -10,7 +10,7 @@ from jvcli.client.lib.page import Page
 def render(router: StreamlitRouter) -> None:
     """Render the dashboard page."""
     if actions_data := st.session_state.get("actions_data"):
-        with elements("dashboard"):
+        with elements("action_dashboard"):
             columns = 4
             layout = []
 
@@ -20,7 +20,7 @@ def render(router: StreamlitRouter) -> None:
                 y = (idx // columns) * 2
                 width = 3
                 height = 2
-                # Add an item to the dashboard manually without using `with` if it's not a context manager
+                # Add an item to the action_dashboard manually without using `with` if it's not a context manager
                 layout.append(
                     dashboard.Item(
                         f"card_{idx}",
@@ -36,10 +36,11 @@ def render(router: StreamlitRouter) -> None:
             # now populate the actual cards with content
             with dashboard.Grid(layout):
                 for idx, action in enumerate(actions_data):
+
                     package = action.get("_package", {})
                     title = package.get("meta", {}).get("title", action.get("label"))
                     description = action.get("description", "")
-                    version = action.get("version", "0.0.0")
+                    version = package.get("version", "0.0.0")
                     action_type = package.get("meta", {}).get("type", "action")
                     key = Page.normalize_label(title)
                     enabled_color = "red"

{jvcli-2.0.15 → jvcli-2.0.17}/jvcli/client/pages/analytics_page.py

@@ -3,6 +3,7 @@
 import calendar
 import datetime
 import os
+from typing import Optional
 
 import pandas as pd
 import requests
@@ -11,14 +12,79 @@ from streamlit.delta_generator import DeltaGenerator
 from streamlit_javascript import st_javascript
 from streamlit_router import StreamlitRouter
 
-from jvcli.client.lib.utils import get_user_info
+from jvcli.client.lib.utils import call_healthcheck, get_user_info
 
-JIVAS_URL = os.environ.get("JIVAS_URL", "http://localhost:8000")
+JIVAS_BASE_URL = os.environ.get("JIVAS_BASE_URL", "http://localhost:8000")
 
 
 def render(router: StreamlitRouter) -> None:
     """Render the analytics page."""
-    ctx = get_user_info()
+
+    selected_agent = st.session_state.get("selected_agent")
+
+    # Call the healthcheck endpoint and render the collapsible section
+    @st.cache_data(show_spinner=True)
+    def fetch_healthcheck(agent_id: str) -> Optional[dict]:
+        return call_healthcheck(agent_id)
+
+    health_data = None
+
+    if selected_agent:
+        # Clear the cache and fetch fresh data if the button is clicked
+        if st.session_state.get("recheck_health_clicked", False):
+            fetch_healthcheck.clear()
+            health_data = call_healthcheck(selected_agent["id"])
+            st.session_state["recheck_health_clicked"] = False
+        else:
+            # Use cached data
+            health_data = fetch_healthcheck(selected_agent["id"])
+
+        try:
+            if health_data:
+                trace = health_data.get("trace", {})
+                errors = [
+                    f"{key}: {value['message']}"
+                    for key, value in trace.items()
+                    if value.get("severity") == "error"
+                ]
+                warnings = [
+                    f"{key}: {value['message']}"
+                    for key, value in trace.items()
+                    if value.get("severity") == "warning"
+                ]
+
+                if errors:
+                    section_label = "Agent health needs ATTENTION!"
+                    section_color = "red"
+                    expanded = True
+                elif warnings:
+                    section_label = "Agent health is OK (with warnings)"
+                    section_color = "orange"
+                    expanded = True
+                else:
+                    section_label = "Agent health is OK"
+                    section_color = "green"
+                    expanded = False
+
+                with st.expander(
+                    f":{section_color}[{section_label}]", expanded=expanded
+                ):
+                    if errors:
+                        st.error("Errors")
+                        for error in errors:
+                            st.text(f"- {error}")
+                    if warnings:
+                        st.warning("Warnings")
+                        for warning in warnings:
+                            st.text(f"- {warning}")
+                    if st.button("Recheck Health", key="recheck_inside_expander"):
+                        st.session_state["recheck_health_clicked"] = True
+
+            else:
+                st.error("Failed to fetch healthcheck data.")
+        except Exception as e:
+            st.error("An error occurred while fetching healthcheck data.")
+            print(e)
 
     st.header("Analytics", divider=True)
     today = datetime.date.today()
@@ -45,7 +111,7 @@ def render(router: StreamlitRouter) -> None:
     )
 
     try:
-        selected_agent = st.session_state.get("selected_agent")
+        ctx = get_user_info()
         if selected_agent and end_date > start_date:
             interactions_chart(
                 token=ctx["token"],
@@ -87,7 +153,7 @@ def interactions_chart(
     timezone: str,
 ) -> None:
     """Render the interactions chart."""
-    url = f"{JIVAS_URL}/walker/get_interactions_by_date"
+    url = f"{JIVAS_BASE_URL}/walker/get_interactions_by_date"
 
     with st.container(border=True):
         st.subheader("Interactions by Date")
@@ -121,7 +187,7 @@ def users_chart(
     timezone: str,
 ) -> None:
     """Render the users chart."""
-    url = f"{JIVAS_URL}/walker/get_users_by_date"
+    url = f"{JIVAS_BASE_URL}/walker/get_users_by_date"
     with st.container(border=True):
         st.subheader("Users by Date")
         response = requests.post(
@@ -154,7 +220,7 @@ def channels_chart(
     timezone: str,
 ) -> None:
     """Render the channels chart."""
-    url = f"{JIVAS_URL}/walker/get_channels_by_date"
+    url = f"{JIVAS_BASE_URL}/walker/get_channels_by_date"
     with st.container(border=True):
         st.subheader("Channels by Date")
         response = requests.post(

{jvcli-2.0.15 → jvcli-2.0.17}/jvcli/client/pages/chat_page.py

@@ -9,12 +9,12 @@ from streamlit_router import StreamlitRouter
 
 from jvcli.client.lib.utils import get_user_info
 
-JIVAS_URL = os.environ.get("JIVAS_URL", "http://localhost:8000")
+JIVAS_BASE_URL = os.environ.get("JIVAS_BASE_URL", "http://localhost:8000")
 
 
 def transcribe_audio(token: str, agent_id: str, file: bytes) -> dict:
     """Transcribe audio using the walker API."""
-    action_walker_url = f"{JIVAS_URL}/action/walker"
+    action_walker_url = f"{JIVAS_BASE_URL}/action/walker"
 
     # Create form data
     files = {"attachments": ("audio.wav", file, "audio/wav")}
@@ -41,7 +41,7 @@ def transcribe_audio(token: str, agent_id: str, file: bytes) -> dict:
 
 def render(router: StreamlitRouter) -> None:
     """Render the chat page."""
-    url = f"{JIVAS_URL}/interact"
+    url = f"{JIVAS_BASE_URL}/interact"
     ctx = get_user_info()
 
     st.header("Chat", divider=True)

{jvcli-2.0.15 → jvcli-2.0.17}/jvcli/commands/client.py

@@ -17,7 +17,7 @@ def client() -> None:
 @click.option("--port", default=8501, help="Port for the client to launch on.")
 @click.option(
     "--jivas_url",
-    default=os.environ.get("JIVAS_URL", "http://localhost:8000"),
+    default=os.environ.get("JIVAS_BASE_URL", "http://localhost:8000"),
     help="URL for the Jivas API.",
 )
 @click.option(
@@ -30,7 +30,7 @@ def launch(port: int, jivas_url: str, studio_url: str) -> None:
     click.echo(
         f"Launching Jivas Client on port {port}, loading action apps from {jivas_url}..."
     )
-    os.environ["JIVAS_URL"] = jivas_url
+    os.environ["JIVAS_BASE_URL"] = jivas_url
     os.environ["JIVAS_STUDIO_URL"] = studio_url
     subprocess.call(
         [

{jvcli-2.0.15 → jvcli-2.0.17}/jvcli/commands/create.py

@@ -331,7 +331,7 @@ def create_namespace(name: str) -> None:
 )
 @click.option(
     "--path",
-    default="./dafs",
+    default="./daf",
     show_default=True,
     help="Directory to create the agent.",
 )

{jvcli-2.0.15 → jvcli-2.0.17}/jvcli/commands/download.py

@@ -87,7 +87,7 @@ def _download_package(name: str, version: str, path: str, pkg_type: str) -> None
 
                 # checking for both daf and agent to maintain backward compatibility
                 if pkg_type == "agent" and package_type in ["agent", "daf"]:
-                    base_dir = "dafs"
+                    base_dir = "daf"
                 elif pkg_type == "action" and package_type.endswith("action"):
                     base_dir = "actions"
                 else:

{jvcli-2.0.15 → jvcli-2.0.17}/jvcli/commands/startproject.py

@@ -16,12 +16,18 @@ from jvcli.utils import TEMPLATES_DIR
     show_default=True,
     help="Jivas project version to use for scaffolding.",
 )
-def startproject(project_name: str, version: str) -> None:
+@click.option(
+    "--no-env",
+    is_flag=True,
+    default=False,
+    help="Skip generating the .env file.",
+)
+def startproject(project_name: str, version: str, no_env: bool) -> None:
     """
     Initialize a new Jivas project with the necessary structure.
 
     Usage:
-        jvcli startproject <project_name> [--version <jivas_version>]
+        jvcli startproject <project_name> [--version <jivas_version>] [--no-env]
     """
 
     template_path = os.path.join(TEMPLATES_DIR, version, "project")
@@ -69,12 +75,13 @@ def startproject(project_name: str, version: str) -> None:
                         gitignore_file.write(contents)
 
                 if file_name == "env.example":
-                    # Write `.env`
-                    target_file_path_env = os.path.join(target_dir, ".env")
-                    with open(target_file_path_env, "w") as env_file:
-                        env_file.write(contents)
+                    # Write `.env` only if no-env flag is not set
+                    if not no_env:
+                        target_file_path_env = os.path.join(target_dir, ".env")
+                        with open(target_file_path_env, "w") as env_file:
+                            env_file.write(contents)
 
-                    # Write `env.example`
+                    # Always write `env.example`
                     target_file_path_example = os.path.join(target_dir, "env.example")
                     with open(target_file_path_example, "w") as example_file:
                         example_file.write(contents)
@@ -83,7 +90,7 @@ def startproject(project_name: str, version: str) -> None:
                     project_file.write(contents)
 
         click.secho(
-            f"Successfully created Jivas project: {project_name} (Version: {version})",
+            f"Successfully created Jivas project: {project_name} (Version: {version}){' (without .env file)' if no_env else ''}",
             fg="green",
         )
 

{jvcli-2.0.15 → jvcli-2.0.17}/jvcli/templates/2.0.0/project/daf/README.md

@@ -21,7 +21,7 @@ To create a new DAF package using `jvcli`, follow these steps:
 2. **Options**: You can customize the creation process with various options:
     - `--version`: Specify the version of the agent. Default is `0.0.1`.
     - `--jivas_version`: Specify the version of Jivas. Default is `2.0.0`.
-    - `--path`: Directory to create the agent folder in. Default is `./dafs`.
+    - `--path`: Directory to create the agent folder in. Default is `./daf`.
     - `--namespace`: Namespace for the agent. Defaults to the username in the token.
 
 3. **Example**: