jvcli 2.0.0__py3-none-any.whl

jvcli/commands/publish.py

@@ -0,0 +1,207 @@
+"""Publish command group for the Jivas Package Repository CLI."""
+
+import os
+import tempfile
+
+import click
+from pyaml import yaml
+
+from jvcli.api import RegistryAPI
+from jvcli.auth import load_token
+from jvcli.utils import (
+    compress_package_to_tgz,
+    validate_dependencies,
+    validate_package_name,
+    validate_yaml_format,
+)
+
+
+# Main `publish` group command
+@click.group()
+def publish() -> None:
+    """
+    Publish resources to the Jivas environment.
+    Available subcommands: action, agent.
+    """
+    pass  # pragma: no cover
+
+
+@publish.command(name="action")
+@click.option(
+    "--path",
+    required=True,
+    help="Path to the directory containing the action to publish.",
+)
+@click.option(
+    "--visibility",
+    type=click.Choice(["public", "private"], case_sensitive=False),
+    default="public",
+    show_default=True,
+    help="Visibility of the published action (public or private).",
+)
+@click.option(
+    "--package-only",
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="Only generate the package without publishing.",
+)
+@click.option(
+    "--output",
+    "-o",
+    default=None,
+    required=False,
+    help="Output path for generated package.",
+)
+@click.option(
+    "--namespace",
+    required=False,  # Initially not required
+    help="Namespace of the package (required when --path is a tarball).",
+)
+def publish_action(
+    path: str, visibility: str, package_only: bool, output: str, namespace: str
+) -> None:
+    """Publish an action to the Jivas environment."""
+
+    if path.endswith(".tar.gz") and not namespace:
+        raise ValueError("--namespace is required when --path is a tarball (.tar.gz).")
+
+    _publish_common(path, visibility, package_only, output, "action", namespace)
+
+
+@publish.command(name="agent")
+@click.option(
+    "--path",
+    required=True,
+    help="Path to the directory containing the agent to publish.",
+)
+@click.option(
+    "--visibility",
+    type=click.Choice(["public", "private"], case_sensitive=False),
+    default="public",
+    show_default=True,
+    help="Visibility of the published agent (public or private).",
+)
+@click.option(
+    "--package-only",
+    is_flag=True,
+    default=False,
+    show_default=True,
+    help="Only generate the package without publishing.",
+)
+@click.option(
+    "--output",
+    "-o",
+    required=False,
+    help="Output path for generated package.",
+)
+@click.option(
+    "--namespace",
+    required=False,  # Initially not required
+    help="Namespace of the package (required when --path is a tarball).",
+)
+def publish_agent(
+    path: str, visibility: str, package_only: bool, output: str, namespace: str
+) -> None:
+    """Publish an agent to the Jivas environment."""
+
+    if path.endswith(".tar.gz") and not namespace:
+        raise ValueError("--namespace is required when --path is a tarball (.tar.gz).")
+
+    _publish_common(path, visibility, package_only, output, "agent", namespace)
+
+
+def _publish_common(
+    path: str,
+    visibility: str,
+    package_only: bool,
+    output: str,
+    publish_type: str,
+    namespace: str,
+) -> None:
+
+    token = load_token().get("token")
+    if not token and not package_only:
+        click.secho("You need to login first.", fg="red")
+        return
+
+    # Check if path is directory
+    if os.path.isdir(path):
+
+        info_path = os.path.join(path, "info.yaml")
+        if not os.path.exists(info_path):
+            click.secho(
+                f"Error: 'info.yaml' not found in the directory '{path}'.", fg="red"
+            )
+            return
+
+        click.secho(f"Preparing {publish_type} from directory: {path}", fg="yellow")
+
+        with open(info_path, "r") as info_file:
+            info_data = yaml.safe_load(info_file)
+
+        if validate_yaml_format(info_data, type=publish_type):
+            click.secho("info.yaml validated successfully.", fg="yellow")
+        else:
+            click.secho(f"Error validating 'info.yaml' for {publish_type}.", fg="red")
+            return
+
+        try:
+            package_name = info_data["package"].get("name")
+            validate_package_name(package_name)
+            click.secho(
+                f"Package name '{package_name}' validated successfully.", fg="yellow"
+            )
+        except ValueError as e:
+            click.secho(f"Error validating package name: {e}", fg="red")
+            return
+
+        try:
+            validate_dependencies(info_data["package"].get("dependencies", {}))
+            click.secho("Dependencies validated successfully.", fg="yellow")
+        except ValueError as e:
+            click.secho(f"Error validating dependencies: {e}", fg="red")
+            return
+
+        namespace, name = package_name.split("/", 1)
+
+        if package_only and not output:
+            output = "."
+
+        tgz_file_path = _prepare_package(namespace, name, path, publish_type, output)
+        click.secho(f"Compressed {publish_type} to: {tgz_file_path}", fg="yellow")
+
+    # check if path is already a tgz file
+    elif path.endswith(".tar.gz"):
+        click.secho(f"Preparing {publish_type} from tgz file: {path}", fg="yellow")
+        tgz_file_path = path
+
+    else:
+        click.secho(
+            f"Unable to publish {publish_type} from the path: {path}, unsupported file format"
+        )
+        return
+
+    if not package_only:
+        click.secho(
+            f"Publishing {publish_type} with visibility: {visibility}", fg="blue"
+        )
+        response = RegistryAPI.publish_action(
+            tgz_file_path, visibility, str(token), namespace or ""
+        )
+        if response:
+            click.secho(
+                f"{publish_type.capitalize()} published successfully!", fg="green"
+            )
+
+
+def _prepare_package(
+    namespace: str, name: str, path: str, publish_type: str, output: str
+) -> str:
+    """Prepare the package for publishing."""
+    tgz_filename = os.path.join(
+        output if output else tempfile.gettempdir(), f"{namespace}_{name}.tar.gz"
+    )
+    tgz_file_path = compress_package_to_tgz(path, tgz_filename)
+    click.secho(f"Compressed {publish_type} to: {tgz_file_path}", fg="yellow")
+    return tgz_file_path

jvcli/commands/studio.py

@@ -0,0 +1,96 @@
+"""Studio command group for deploying and interfacing with the Jivas Studio."""
+
+import json
+from pathlib import Path
+
+import click
+import jaclang  # noqa: F401
+from bson import ObjectId
+from jac_cloud.core.architype import NodeAnchor
+from uvicorn import run
+
+
+@click.group()
+def studio() -> None:
+    """Group for managing Jivas Studio resources."""
+    pass  # pragma: no cover
+
+
+def get_graph(root: str) -> dict:
+    """Fetches a graph structure from the database."""
+    nodes = []
+    edges = []
+
+    edge_collection = NodeAnchor.Collection.get_collection("edge")
+    node_collection = NodeAnchor.Collection.get_collection("node")
+    node_docs = node_collection.find({"root": ObjectId(root)})
+    edge_docs = edge_collection.find({"root": ObjectId(root)})
+
+    for node in node_docs:
+        nodes.append(
+            {
+                "id": node["_id"],
+                "data": node["architype"],
+                "name": node["name"],
+            }
+        )
+    for edge in edge_docs:
+        edges.append(
+            {
+                "id": edge["_id"],
+                "name": edge["name"],
+                "source": edge["source"],
+                "target": edge["target"],
+                "data": edge["architype"],
+            }
+        )
+
+    return {
+        "nodes": json.loads(json.dumps(nodes, default=str)),
+        "edges": json.loads(json.dumps(edges, default=str)),
+    }
+
+
+def get_users() -> list:
+    """Fetches users from the database."""
+    users = []
+    user_collection = NodeAnchor.Collection.get_collection("user")
+    user_docs = user_collection.find()
+
+    for user in user_docs:
+        users.append(
+            {
+                "id": user["_id"],
+                "root_id": user["root_id"],
+                "email": user["email"],
+            }
+        )
+
+    return json.loads(json.dumps(users, default=str))
+
+
+@studio.command()
+@click.option("--port", default=8989, help="Port for the studio to launch on.")
+def launch(port: int) -> None:
+    """Launch the Jivas Studio on the specified port."""
+    click.echo(f"Launching Jivas Studio on port {port}...")
+    from fastapi import FastAPI
+    from fastapi.middleware.cors import CORSMiddleware
+    from fastapi.staticfiles import StaticFiles
+
+    app = FastAPI()
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.add_api_route("/graph", endpoint=get_graph, methods=["GET"])
+    app.add_api_route("/users", endpoint=get_users, methods=["GET"])
+
+    client_dir = Path(__file__).resolve().parent.parent.joinpath("client")
+    app.mount("/", StaticFiles(directory=client_dir, html=True), name="studio")
+
+    run(app, host="0.0.0.0", port=port)

jvcli/commands/update.py

@@ -0,0 +1,67 @@
+"""Update command group operations for Jivas Package Repository CLI tool."""
+
+import click
+
+from jvcli.api import RegistryAPI
+from jvcli.auth import load_token
+
+
+@click.group()
+def update() -> None:
+    """Group for updating resources like namespaces."""
+    pass  # pragma: no cover
+
+
+@update.command(name="namespace")
+@click.argument("namespace", required=True)
+@click.option(
+    "--invite",
+    type=str,
+    help="Invite a user to the namespace by their email.",
+    metavar="EMAIL",
+)
+@click.option(
+    "--transfer",
+    type=str,
+    help="Transfer ownership of the namespace to a specified user by their email.",
+    metavar="EMAIL",
+)
+@click.pass_context
+def namespace(ctx: click.Context, namespace: str, invite: str, transfer: str) -> None:
+    """
+    Update operations for a specified namespace.
+    Use one of the available options: --invite, --transfer.
+    """
+
+    token = load_token().get("token")
+    if not token:
+        click.secho("You need to login first.", fg="red")
+        ctx.exit(1)
+
+    # Validate mutually exclusive options
+    if invite and transfer:
+        click.secho(
+            "You can only use one of --invite or --transfer at a time.", fg="red"
+        )
+        ctx.exit(1)
+
+    # Handle different operations
+    if invite:
+        click.secho(f"Inviting '{invite}' to namespace '{namespace}'...", fg="yellow")
+        # Logic to invite a user to the namespace
+        RegistryAPI.invite_user_to_namespace(
+            namespace_name=namespace, user_email=invite, token=str(token)
+        )
+    elif transfer:
+        click.secho(
+            f"Transferring ownership of namespace '{namespace}' to '{transfer}'...",
+            fg="yellow",
+        )
+        # Logic to transfer ownership of the namespace
+        RegistryAPI.transfer_namespace_ownership(
+            namespace_name=namespace, new_owner_email=transfer, token=str(token)
+        )
+
+    click.secho(
+        f"Operation on namespace '{namespace}' completed successfully.", fg="green"
+    )

jvcli/templates/2.0.0/action_info.yaml

@@ -0,0 +1,14 @@
+package:
+  name: "{{name}}"
+  author: "{{author}}"
+  architype: "{{architype}}"
+  version: "{{version}}"
+  meta:
+    title: "{{title}}"
+    description: "{{description}}"
+    group: "{{group}}"
+    type: "{{type}}"
+  config:
+    singleton: "{{singleton}}"
+  dependencies:
+    jivas: "~{{jivas_version}}"

jvcli/templates/2.0.0/agent_descriptor.yaml

@@ -0,0 +1,30 @@
+published: true
+name: "{{name}}"
+description: |-
+  {{description}}
+actions:
+  - action: jivas/intro_interact_action
+    context:
+      version: "0.0.1"
+      enabled: true
+      prompt: "In a natural and brief manner:\na. Introduce yourself by name and explain your role."
+  - action: jivas/persona_interact_action
+    context:
+      version: "0.0.1"
+      enabled: true
+      anchors: []
+      timezone: "UTC"
+      history: true
+      user_model: true
+      history_size: 2
+      max_statement_length: 800
+      model_name: "gpt-4o"
+  - action: jivas/agent_utils_action
+    context:
+      version: "0.0.1"
+      enabled: true
+  - action: jivas/langchain_model_action
+    context:
+      version: "0.0.1"
+      enabled: true
+      api_key: ""

jvcli/templates/2.0.0/agent_info.yaml

@@ -0,0 +1,10 @@
+package:
+  name: "{{name}}"
+  author: "{{author}}"
+  version: "{{version}}"
+  meta:
+    title: "{{title}}"
+    description: "{{description}}"
+    type: "agent"
+  dependencies:
+    jivas: "~{{jivas_version}}"

jvcli/templates/2.0.0/agent_knowledge.yaml

@@ -0,0 +1,14 @@
+- metadata:
+    knode_index: Example, Knode, Index
+    anchors:
+      - What does this do?
+      - What is JIVAS?
+  text: |2-
+
+    # Example
+
+    ## Example Questions:
+    - What is JIVAS?
+
+    ## Answer:
+    JIVAS is a framework for building agents that can interact with the world.

jvcli/templates/2.0.0/agent_memory.yaml

@@ -0,0 +1 @@
+- memory:

jvcli/templates/CHANGELOG.md

@@ -0,0 +1,2 @@
+## {{version}}
+- Initialized {{package_type}} package using jvcli

jvcli/templates/README.md

@@ -0,0 +1,4 @@
+##  {{name}}
+{{description}}
+
+version: {{version}}

jvcli/utils.py

@@ -0,0 +1,209 @@
+"""Utility functions for the Jivas Package Repository CLI tool."""
+
+import os
+import re
+import tarfile
+
+import click
+import yaml
+from packaging.specifiers import SpecifierSet
+from packaging.version import parse as parse_version
+
+from jvcli import __supported__jivas__versions__
+from jvcli.api import RegistryAPI
+from jvcli.auth import load_token
+
+TEMPLATES_DIR = os.path.join(os.path.dirname(__file__), "templates")
+
+
+def validate_snake_case(ctx: click.Context, param: click.Parameter, value: str) -> str:
+    """Validate that the input is in snake_case."""
+    if not re.match(r"^[a-z0-9_]+$", value):
+        raise click.BadParameter(
+            "must be snake_case (lowercase letters, numbers, and underscores only)."
+        )
+    return value
+
+
+def validate_name(ctx: click.Context, param: click.Parameter, value: str) -> str:
+    """Validate that the input only contains lowercase letters and numbers. Used for validating names."""
+    if not re.match(r"^[a-z0-9]+$", value):
+        raise click.BadParameter("must be lowercase letters and numbers only.")
+    return value
+
+
+def validate_yaml_format(info_data: dict, type: str, version: str = "latest") -> bool:
+    """Validate if the info.yaml data matches the corresponding version template."""
+    if version == "latest":
+        version = max(__supported__jivas__versions__)
+
+    if type == "action" or type.endswith("action"):
+        template_path = os.path.join(TEMPLATES_DIR, version, "action_info.yaml")
+
+    if type == "daf" or type == "agent":
+        template_path = os.path.join(TEMPLATES_DIR, version, "agent_info.yaml")
+
+    if not os.path.exists(template_path):
+        click.secho(f"Template for version {version} not found.", fg="red")
+        return False
+
+    # Load template
+    with open(template_path, "r") as template_file:
+        # Fill placeholders to avoid YAML error
+        template_content = template_file.read().format(
+            dict.fromkeys(info_data.keys(), "")
+        )
+        template_data = yaml.safe_load(template_content)
+
+    # Compare keys
+    if set(info_data.keys()) != set(template_data.keys()):
+        missing_keys = set(template_data.keys()) - set(info_data.keys())
+        extra_keys = set(info_data.keys()) - set(template_data.keys())
+
+        if extra_keys:
+            click.secho(
+                f"Warning: Extra keys: {extra_keys} found in info.yaml, the jivas package repository may ignore them.",
+                fg="yellow",
+            )
+
+        if missing_keys:
+            click.secho(
+                f"info.yaml validation failed. Missing keys: {missing_keys}",
+                fg="red",
+            )
+            return False
+    return True
+
+
+def validate_package_name(name: str) -> None:
+    """Ensure the package name includes a namespace and matches user access."""
+    if "/" not in name:
+        raise ValueError(
+            f"Package name '{name}' must include a namespace (e.g., 'namespace/action_name')."
+        )
+
+    namespace, _ = name.split("/", 1)
+    namespaces = load_token().get("namespaces", {}).get("groups", [])
+    if namespace not in namespaces:
+        raise ValueError(
+            f"Namespace '{namespace}' is not accessible to the current user."
+        )
+
+
+def is_version_compatible(version: str, specifiers: str) -> bool:
+    """
+    Compares the provided version to a given set of specifications/modifiers or exact version match.
+
+    Args:
+    - version (str): The version to be compared. E.g., "2.1.0".
+    - specifiers (str): The version specifier set or exact version. E.g., "2.1.0" or ">=0.2,<0.3" or "0.0.1" or "^2.0.0"
+
+    Returns:
+    - bool: True if the version satisfies the specifier set or exact match, False otherwise.
+    """
+    try:
+        # Parse the version to check
+        version = parse_version(version)
+
+        # Check if specifiers is a simple exact version match
+        try:
+            exact_version = parse_version(specifiers)
+            return version == exact_version
+        except Exception:
+            # If parsing fails, treat it as a specifier set
+            pass
+
+        # Handle "~" shorthand by translating it to a compatible range
+        if specifiers.startswith("~"):
+            base_version = specifiers[1:]
+            parsed_base = parse_version(base_version)
+            major = parsed_base.major
+            minor = parsed_base.minor
+            # Assuming the next release constraint is on minor bump
+            upper_bound = f"<{major}.{minor + 1}"
+            specifiers = f">={base_version},{upper_bound}"
+
+        # Handle "^" shorthand to translate to a compatible range
+        if specifiers.startswith("^"):
+            base_version = specifiers[1:]
+            parsed_base = parse_version(base_version)
+            major = parsed_base.major
+            minor = parsed_base.minor
+            patch = parsed_base.micro
+            if major > 0:
+                upper_bound = f"<{major + 1}.0.0"
+            elif minor > 0:
+                upper_bound = f"<0.{minor + 1}.0"
+            else:
+                upper_bound = f"<0.0.{patch + 1}"
+            specifiers = f">={base_version},{upper_bound}"
+
+        # Create a SpecifierSet with the given specifiers
+        spec_set = SpecifierSet(specifiers)
+
+        # Check if the version matches the specifier set
+        return version in spec_set
+
+    except Exception as e:
+        # Handle exceptions if the inputs are malformed or invalid
+        click.secho(f"Error comparing versions: {e}", fg="red")
+        return False
+
+
+def validate_dependencies(dependencies: dict) -> None:
+    """Ensure all dependencies exist in the registry."""
+    missing_dependencies = []
+    for dep, specifier in dependencies.items():
+        if dep == "jivas":
+            # Check if the version is in list of supported versions
+            def supported(spec: str) -> bool:
+                return any(
+                    is_version_compatible(version, spec)
+                    for version in __supported__jivas__versions__
+                )
+
+            if not supported(specifier):
+                missing_dependencies.append(f"{dep} {specifier}")
+        elif dep == "actions":
+            # Check if action exists in the registry
+            for name, spec in specifier.items():
+                package = RegistryAPI.download_package(
+                    name=name, version=spec, suppress_error=True
+                )
+
+                if not package:
+                    missing_dependencies.append(f"{dep} {specifier}")
+        elif dep == "pip":
+            # TODO: Add support for pip dependencies
+            continue
+        else:
+            raise ValueError(f"Unknown dependency type: {dep}")
+
+    if missing_dependencies:
+        raise ValueError(f"Dependencies not found in registry: {missing_dependencies}")
+
+
+def compress_package_to_tgz(source_path: str, output_filename: str) -> str:
+    """
+    Compress the action folder into a .tgz file with the required structure,
+    excluding the __jac_gen__ folder.
+
+    Args:
+        source_path (str): Path to the action directory.
+        output_filename (str): Desired name of the output .tgz file.
+
+    Returns:
+        str: Path to the .tgz file.
+    """
+    with tarfile.open(output_filename, "w:gz") as tar:
+        for root, dirs, files in os.walk(source_path):
+            # Exclude the __jac_gen__ folder
+            if "__jac_gen__" in dirs:
+                dirs.remove("__jac_gen__")
+            if "__pycache__" in dirs:
+                dirs.remove("__pycache__")
+            for file in files:
+                file_path = os.path.join(root, file)
+                arcname = os.path.relpath(file_path, start=source_path)
+                tar.add(file_path, arcname=arcname)
+    return output_filename