pygeai 0.6.0b11__py3-none-any.whl → 0.6.0b12__py3-none-any.whl

pygeai/cli/commands/migrate.py

@@ -11,6 +11,7 @@ from pygeai.assistant.managers import AssistantManager
 from pygeai.assistant.rag.clients import RAGAssistantClient
 from pygeai.assistant.rag.mappers import RAGAssistantMapper
 from pygeai.core.files.managers import FileManager
+from pygeai.core.secrets.clients import SecretClient
 from pygeai.migration.strategies import (
     ProjectMigrationStrategy,
     AgentMigrationStrategy,
@@ -19,7 +20,8 @@ from pygeai.migration.strategies import (
     TaskMigrationStrategy,
     UsageLimitMigrationStrategy,
     RAGAssistantMigrationStrategy,
-    FileMigrationStrategy
+    FileMigrationStrategy,
+    SecretMigrationStrategy
 )
 from pygeai.migration.tools import MigrationTool, MigrationPlan, MigrationOrchestrator
 from pygeai.admin.clients import AdminClient
@@ -216,7 +218,7 @@ def select_resource_types() -> List[int]:
     """
     Prompt user to select which resource types to migrate.
     
-    :return: List of integers representing selected resource types (1-7)
+    :return: List of integers representing selected resource types (1-8)
     """
     Console.write_stdout("\n--- Resource Type Selection ---")
     Console.write_stdout("Which resource types do you want to migrate?")
@@ -227,15 +229,16 @@ def select_resource_types() -> List[int]:
     Console.write_stdout("  5. RAG Assistants")
     Console.write_stdout("  6. Files")
     Console.write_stdout("  7. Usage Limits")
+    Console.write_stdout("  8. Secrets")
     
     while True:
         resource_choice = input("\nSelect resource types (comma-separated numbers, or empty for all): ").strip()
         if not resource_choice:
-            return [1, 2, 3, 4, 5, 6, 7]
+            return [1, 2, 3, 4, 5, 6, 7, 8]
         try:
             resource_types = [int(x.strip()) for x in resource_choice.split(",")]
-            if any(i < 1 or i > 7 for i in resource_types):
-                Console.write_stdout("Error: Invalid selection. Numbers must be between 1 and 7.")
+            if any(i < 1 or i > 8 for i in resource_types):
+                Console.write_stdout("Error: Invalid selection. Numbers must be between 1 and 8.")
                 continue
             return resource_types
         except ValueError:
@@ -368,6 +371,29 @@ def fetch_and_select_files(
     return None
 
 
+def fetch_and_select_secrets(from_api_key: str, from_instance: str) -> Optional[str]:
+    """
+    Fetch and prompt user to select secrets for migration.
+    
+    :param from_api_key: Source API key
+    :param from_instance: Source instance URL
+    :return: Comma-separated secret IDs, 'all', or None
+    """
+    try:
+        secret_client = SecretClient(api_key=from_api_key, base_url=from_instance)
+        secrets_data = secret_client.list_secrets(count=1000)
+        secrets_list = secrets_data.get("secrets", []) if isinstance(secrets_data, dict) else []
+        
+        if secrets_list:
+            secrets_objects = [type('obj', (object,), {'id': s.get('id'), 'name': s.get('name')})() 
+                             for s in secrets_list if s.get('id')]
+            selection = prompt_resource_selection("secrets", secrets_objects, id_field="id", name_field="name")
+            return selection
+    except Exception as e:
+        Console.write_stdout(f"Warning: Could not retrieve secrets: {e}")
+    return None
+
+
 def handle_usage_limits_keys(
     same_instance: bool,
     from_organization_api_key: Optional[str],
@@ -554,6 +580,11 @@ def clone_project_interactively() -> None:
         )
         selected_resources["usage_limits"] = True
     
+    if 8 in resource_types_to_migrate:
+        selection = fetch_and_select_secrets(from_api_key, from_instance)
+        if selection:
+            selected_resources["secrets"] = selection
+    
     confirmed, stop_on_error = show_summary_and_confirm(from_instance, from_project_id, to_instance, to_project_name, to_project_id, selected_resources)
     if not confirmed:
         Console.write_stdout("Migration cancelled.")
@@ -571,7 +602,7 @@ def clone_project(option_list: list) -> None:
     Clone a project with selected components from source to destination instance.
     
     Supports migration of agents, tools, agentic processes, tasks, usage limits,
-    RAG assistants, and files between GenExus AI instances.
+    RAG assistants, files, and secrets between GEAI instances.
     
     :param option_list: List of (option_flag, option_value) tuples from CLI parsing
     """
@@ -606,6 +637,7 @@ def clone_project(option_list: list) -> None:
     migrate_usage_limits = False
     migrate_rag_assistants = False
     migrate_files = False
+    migrate_secrets = False
     
     agent_ids = None
     tool_ids = None
@@ -613,6 +645,7 @@ def clone_project(option_list: list) -> None:
     task_ids = None
     assistant_names = None
     file_ids = None
+    secret_ids = None
     
     stop_on_error = True
 
@@ -663,6 +696,9 @@ def clone_project(option_list: list) -> None:
         elif option_flag.name == "files":
             migrate_files = True
             file_ids = option_arg if option_arg else "all"
+        elif option_flag.name == "secrets":
+            migrate_secrets = True
+            secret_ids = option_arg if option_arg else "all"
         elif option_flag.name == "stop_on_error":
             from pygeai.cli.commands.common import get_boolean_value
             stop_on_error = get_boolean_value(option_arg)
@@ -778,12 +814,14 @@ def clone_project(option_list: list) -> None:
         migrate_usage_limits = True if from_organization_id and to_organization_id else False
         migrate_rag_assistants = True
         migrate_files = True if from_organization_id and to_organization_id else False
+        migrate_secrets = True
         agent_ids = "all"
         tool_ids = "all"
         process_ids = "all"
         task_ids = "all"
         assistant_names = "all"
         file_ids = "all"
+        secret_ids = "all"
 
     strategies = []
     
@@ -954,6 +992,31 @@ def clone_project(option_list: list) -> None:
                     to_instance=to_instance
                 ))
 
+    if migrate_secrets:
+        secret_client = SecretClient(api_key=from_api_key, base_url=from_instance)
+        if secret_ids == "all":
+            secrets_data = secret_client.list_secrets(count=1000)
+            secrets_list = secrets_data.get("secrets", []) if isinstance(secrets_data, dict) else []
+            discovered_secrets = [s.get('id') for s in secrets_list if s.get('id')]
+            Console.write_stdout(f"Discovered {len(discovered_secrets)} secrets")
+            for secret_id in discovered_secrets:
+                strategies.append(SecretMigrationStrategy(
+                    from_api_key=from_api_key,
+                    from_instance=from_instance,
+                    secret_id=secret_id,
+                    to_api_key=to_api_key,
+                    to_instance=to_instance
+                ))
+        elif secret_ids:
+            for secret_id in secret_ids.split(','):
+                strategies.append(SecretMigrationStrategy(
+                    from_api_key=from_api_key,
+                    from_instance=from_instance,
+                    secret_id=secret_id.strip(),
+                    to_api_key=to_api_key,
+                    to_instance=to_instance
+                ))
+
     if not strategies:
         Console.write_stdout("No migration strategies configured. Use flags like --agents, --tools, --all, etc.")
         return
@@ -1098,6 +1161,12 @@ clone_project_options = [
         "File IDs to migrate: comma-separated IDs or 'all' (requires org/project IDs)",
         True
     ),
+    Option(
+        "secrets",
+        ["--secrets"],
+        "Secret IDs to migrate: comma-separated IDs or 'all'",
+        True
+    ),
     Option(
         "stop_on_error",
         ["--stop-on-error", "--soe"],

pygeai/cli/commands/organization.py

@@ -484,6 +484,235 @@ get_organization_members_options = [
     ),
 ]
 
+
+def add_project_member(option_list: list):
+    project_id = None
+    user_email = None
+    roles = []
+    batch_file = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "project_id":
+            project_id = option_arg
+        if option_flag.name == "user_email":
+            user_email = option_arg
+        if option_flag.name == "roles":
+            roles = [r.strip() for r in option_arg.split(",")]
+        if option_flag.name == "batch_file":
+            batch_file = option_arg
+
+    client = OrganizationClient()
+
+    if batch_file:
+        add_project_member_in_batch(client, batch_file)
+    else:
+        if not (project_id and user_email and roles):
+            raise MissingRequirementException("Cannot add project member without project-id, user email, and roles")
+        result = client.add_project_member(project_id, user_email, roles)
+        Console.write_stdout(f"User invitation sent: \n{result}")
+
+
+def add_project_member_in_batch(client: OrganizationClient, batch_file: str):
+    import csv
+    import os
+
+    if not os.path.exists(batch_file):
+        raise MissingRequirementException(f"Batch file not found: {batch_file}")
+
+    successful = 0
+    failed = 0
+    errors = []
+
+    try:
+        with open(batch_file, 'r') as f:
+            csv_reader = csv.reader(f)
+            for line_num, row in enumerate(csv_reader, start=1):
+                if len(row) < 3:
+                    error_msg = f"Line {line_num}: Invalid format - expected at least 3 columns (project_id, email, role1, ...)"
+                    errors.append(error_msg)
+                    failed += 1
+                    continue
+
+                project_id = row[0].strip()
+                email = row[1].strip()
+                roles = [r.strip() for r in row[2:] if r.strip()]
+
+                if not (project_id and email and roles):
+                    error_msg = f"Line {line_num}: Missing required fields (project_id={project_id}, email={email}, roles={roles})"
+                    errors.append(error_msg)
+                    failed += 1
+                    continue
+
+                try:
+                    client.add_project_member(project_id, email, roles)
+                    successful += 1
+                except Exception as e:
+                    error_msg = f"Line {line_num}: Failed to add {email} to project {project_id}: {str(e)}"
+                    errors.append(error_msg)
+                    failed += 1
+
+        Console.write_stdout(f"Batch processing complete: {successful} successful, {failed} failed")
+        if errors:
+            Console.write_stdout("\nErrors:")
+            for error in errors:
+                Console.write_stdout(f"  - {error}")
+    except Exception as e:
+        raise MissingRequirementException(f"Failed to read batch file: {str(e)}")
+
+
+add_project_member_options = [
+    Option(
+        "project_id",
+        ["--project-id", "--pid"],
+        "GUID of the project (required unless --batch is used)",
+        True
+    ),
+    Option(
+        "user_email",
+        ["--email", "-e"],
+        "Email address of the user to invite (required unless --batch is used)",
+        True
+    ),
+    Option(
+        "roles",
+        ["--roles", "-r"],
+        "Comma-separated list of role names or GUIDs (e.g., 'Project member,Project administrator') (required unless --batch is used)",
+        True
+    ),
+    Option(
+        "batch_file",
+        ["--batch", "-b"],
+        "Path to CSV file with format: project_id,email,role1,role2,... (one invitation per line)",
+        True
+    ),
+]
+
+
+def create_organization(option_list: list):
+    name = None
+    email = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "name":
+            name = option_arg
+
+        if option_flag.name == "admin_email":
+            email = option_arg
+
+    if not (name and email):
+        raise MissingRequirementException("Cannot create organization without name and administrator's email")
+
+    client = OrganizationClient()
+    result = client.create_organization(name, email)
+    Console.write_stdout(f"New organization: \\n{result}")
+
+
+create_organization_options = [
+    Option(
+        "name",
+        ["--name", "-n"],
+        "Name of the new organization",
+        True
+    ),
+    Option(
+        "admin_email",
+        ["--email", "-e"],
+        "Organization administrator's email",
+        True
+    ),
+]
+
+
+def get_organization_list(option_list: list):
+    start_page = None
+    page_size = None
+    order_key = None
+    order_direction = "desc"
+    filter_key = None
+    filter_value = None
+
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "start_page":
+            start_page = int(option_arg)
+        if option_flag.name == "page_size":
+            page_size = int(option_arg)
+        if option_flag.name == "order_key":
+            order_key = option_arg
+        if option_flag.name == "order_direction":
+            order_direction = option_arg
+        if option_flag.name == "filter_key":
+            filter_key = option_arg
+        if option_flag.name == "filter_value":
+            filter_value = option_arg
+
+    client = OrganizationClient()
+    result = client.get_organization_list(start_page, page_size, order_key, order_direction, filter_key, filter_value)
+    Console.write_stdout(f"Organization list: \\n{result}")
+
+
+get_organization_list_options = [
+    Option(
+        "start_page",
+        ["--start-page"],
+        "Page number for pagination",
+        True
+    ),
+    Option(
+        "page_size",
+        ["--page-size"],
+        "Number of items per page",
+        True
+    ),
+    Option(
+        "order_key",
+        ["--order-key"],
+        "Field for sorting (only 'name' supported)",
+        True
+    ),
+    Option(
+        "order_direction",
+        ["--order-direction"],
+        "Sort direction: asc or desc (default: desc)",
+        True
+    ),
+    Option(
+        "filter_key",
+        ["--filter-key"],
+        "Field for filtering (only 'name' supported)",
+        True
+    ),
+    Option(
+        "filter_value",
+        ["--filter-value"],
+        "Value to filter by",
+        True
+    ),
+]
+
+
+def delete_organization(option_list: list):
+    organization_id = None
+    for option_flag, option_arg in option_list:
+        if option_flag.name == "organization_id":
+            organization_id = option_arg
+
+    if not organization_id:
+        raise MissingRequirementException("Cannot delete organization without organization-id")
+
+    client = OrganizationClient()
+    result = client.delete_organization(organization_id)
+    Console.write_stdout(f"Deleted organization: \\n{result}")
+
+
+delete_organization_options = [
+    Option(
+        "organization_id",
+        ["--organization-id", "--oid"],
+        "GUID of the organization (required)",
+        True
+    ),
+]
+
 organization_commands = [
     Command(
         "help",
@@ -611,4 +840,40 @@ organization_commands = [
         [],
         get_organization_members_options
     ),
+    Command(
+        "add_project_member",
+        ["add-project-member", "apm"],
+        "Add a user to a project by sending an invitation email",
+        add_project_member,
+        ArgumentsEnum.REQUIRED,
+        [],
+        add_project_member_options
+    ),
+    Command(
+        "create_organization",
+        ["create-organization"],
+        "Create new organization",
+        create_organization,
+        ArgumentsEnum.REQUIRED,
+        [],
+        create_organization_options
+    ),
+    Command(
+        "organization_list",
+        ["list-organizations"],
+        "List organization information",
+        get_organization_list,
+        ArgumentsEnum.OPTIONAL,
+        [],
+        get_organization_list_options
+    ),
+    Command(
+        "delete_organization",
+        ["delete-organization"],
+        "Delete existing organization",
+        delete_organization,
+        ArgumentsEnum.REQUIRED,
+        [],
+        delete_organization_options
+    ),
 ]

pygeai/cli/commands/validators.py

@@ -1,6 +1,8 @@
 from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+import json
 
-from pygeai.core.common.exceptions import WrongArgumentError
+from pygeai.core.common.exceptions import WrongArgumentError, ValidationError
 
 
 def validate_dataset_file(dataset_file: str):
@@ -64,3 +66,144 @@ def validate_system_metric(metric: dict):
 
     if not isinstance(metric["systemMetricWeight"], (int, float)) or not (0 <= metric["systemMetricWeight"] <= 1):
         raise WrongArgumentError('"systemMetricWeight" must be a number between 0 and 1 (inclusive).')
+
+
+def validate_json_input(
+    value: str, 
+    expected_type: type,
+    field_name: str,
+    example: Optional[str] = None
+) -> Union[Dict, List]:
+    """
+    Validates and parses JSON input with detailed error messages.
+
+    :param value: str - The JSON string to parse.
+    :param expected_type: type - Expected type (dict or list).
+    :param field_name: str - Name of the field being validated.
+    :param example: Optional[str] - Example of valid input.
+    :return: Union[Dict, List] - Parsed JSON object.
+    :raises ValidationError: If JSON is invalid or doesn't match expected type.
+    """
+    try:
+        parsed = json.loads(value)
+    except json.JSONDecodeError as e:
+        raise ValidationError(
+            f"Invalid JSON for '{field_name}'",
+            field=field_name,
+            expected="Valid JSON string",
+            received=value[:100] + "..." if len(value) > 100 else value,
+            example=example or '{"key": "value"}'
+        ) from e
+    
+    if not isinstance(parsed, expected_type):
+        raise ValidationError(
+            f"Wrong type for '{field_name}'",
+            field=field_name,
+            expected=expected_type.__name__,
+            received=type(parsed).__name__,
+            example=example
+        )
+    
+    return parsed
+
+
+def validate_numeric_range(
+    value: str,
+    field_name: str,
+    min_value: Optional[float] = None,
+    max_value: Optional[float] = None,
+    value_type: type = float
+) -> Union[int, float]:
+    """
+    Validates numeric input within a specified range.
+
+    :param value: str - The numeric string to validate.
+    :param field_name: str - Name of the field being validated.
+    :param min_value: Optional[float] - Minimum allowed value.
+    :param max_value: Optional[float] - Maximum allowed value.
+    :param value_type: type - Expected numeric type (int or float).
+    :return: Union[int, float] - Validated numeric value.
+    :raises ValidationError: If value is not numeric or out of range.
+    """
+    try:
+        numeric_value = value_type(value)
+    except ValueError as e:
+        raise ValidationError(
+            f"Invalid {value_type.__name__} for '{field_name}'",
+            field=field_name,
+            expected=f"{value_type.__name__}",
+            received=value
+        ) from e
+    
+    if min_value is not None and numeric_value < min_value:
+        raise ValidationError(
+            f"Value too low for '{field_name}'",
+            field=field_name,
+            expected=f">= {min_value}",
+            received=str(numeric_value)
+        )
+    
+    if max_value is not None and numeric_value > max_value:
+        raise ValidationError(
+            f"Value too high for '{field_name}'",
+            field=field_name,
+            expected=f"<= {max_value}",
+            received=str(numeric_value)
+        )
+    
+    return numeric_value
+
+
+def validate_choice(
+    value: str,
+    field_name: str,
+    choices: List[str],
+    case_sensitive: bool = True
+) -> str:
+    """
+    Validates that input is one of the allowed choices.
+
+    :param value: str - The value to validate.
+    :param field_name: str - Name of the field being validated.
+    :param choices: List[str] - List of allowed values.
+    :param case_sensitive: bool - Whether comparison is case-sensitive.
+    :return: str - Validated value.
+    :raises ValidationError: If value is not in choices.
+    """
+    compare_value = value if case_sensitive else value.lower()
+    compare_choices = choices if case_sensitive else [c.lower() for c in choices]
+    
+    if compare_value not in compare_choices:
+        raise ValidationError(
+            f"Invalid value for '{field_name}'",
+            field=field_name,
+            expected=f"One of: {', '.join(choices)}",
+            received=value
+        )
+    
+    return value
+
+
+def validate_boolean_value(value: str, field_name: str = "boolean option") -> bool:
+    """
+    Converts a string argument into a boolean value with flexible input formats.
+
+    :param value: str - A string representation of a boolean.
+    :param field_name: str - Name of the field being validated.
+    :return: bool - The boolean value corresponding to the input.
+    :raises ValidationError: If the input is not a valid boolean representation.
+    """
+    normalized = value.lower().strip()
+    
+    if normalized in ("0", "false", "no", "off"):
+        return False
+    elif normalized in ("1", "true", "yes", "on"):
+        return True
+    else:
+        raise ValidationError(
+            f"Invalid boolean value for '{field_name}'",
+            field=field_name,
+            expected="0/1, true/false, yes/no, on/off",
+            received=value,
+            example="1 or true"
+        )

pygeai/cli/error_handler.py

@@ -1,12 +1,16 @@
 import traceback
 from difflib import SequenceMatcher
-from typing import List, Optional
+from typing import List, Optional, Tuple
 
 from pygeai import logger
 from pygeai.cli.commands import Command, Option
 from pygeai.core.utils.console import Console
 
 
+FUZZY_MATCH_THRESHOLD = 0.6
+MAX_FUZZY_SUGGESTIONS = 3
+
+
 class ExitCode:
     SUCCESS = 0
     USER_INPUT_ERROR = 1
@@ -19,27 +23,58 @@ class ExitCode:
 class ErrorHandler:
 
     @staticmethod
-    def format_error(error_type: str, message: str, suggestion: Optional[str] = None, show_help: bool = True) -> str:
-        output = f"ERROR: {message}"
+    def format_error(
+        error_type: str, 
+        message: str, 
+        suggestion: Optional[str] = None, 
+        show_help: bool = True,
+        example: Optional[str] = None
+    ) -> str:
+        """
+        Formats an error message with optional suggestion and example.
+
+        :param error_type: str - Type of error (e.g., "Unknown Command").
+        :param message: str - The error message.
+        :param suggestion: Optional[str] - Suggested fix or next steps.
+        :param show_help: bool - Whether to show help command hint.
+        :param example: Optional[str] - Example of correct usage.
+        :return: str - Formatted error message.
+        """
+        output = f"ERROR [{error_type}]: {message}"
         
         if suggestion:
             output += f"\n  → {suggestion}"
         
+        if example:
+            output += f"\n\n  Example:\n    {example}"
+        
         if show_help:
             output += "\n\nRun 'geai help' for usage information."
         
         return output
 
     @staticmethod
-    def find_similar_items(item: str, available_items: List[str], threshold: float = 0.6) -> List[str]:
-        similarities = []
+    def find_similar_items(
+        item: str, 
+        available_items: List[str], 
+        threshold: float = FUZZY_MATCH_THRESHOLD
+    ) -> List[str]:
+        """
+        Finds similar items using fuzzy string matching.
+
+        :param item: str - The item to match against.
+        :param available_items: List[str] - List of available items.
+        :param threshold: float - Minimum similarity ratio (0.0 to 1.0).
+        :return: List[str] - List of similar items, up to MAX_FUZZY_SUGGESTIONS.
+        """
+        similarities: List[Tuple[str, float]] = []
         for available in available_items:
             ratio = SequenceMatcher(None, item.lower(), available.lower()).ratio()
             if ratio >= threshold:
                 similarities.append((available, ratio))
         
         similarities.sort(key=lambda x: x[1], reverse=True)
-        return [item[0] for item in similarities[:3]]
+        return [item[0] for item in similarities[:MAX_FUZZY_SUGGESTIONS]]
 
     @staticmethod
     def get_available_commands(commands: List[Command]) -> List[str]: