jac-scale 0.1.1__py3-none-any.whl

jac_scale/abstractions/config/app_config.jac

@@ -0,0 +1,30 @@
+"""Application configuration model for deployments."""
+import from pathlib { Path }
+
+"""Configuration for an application deployment."""
+class AppConfig {
+    has code_folder: str,
+        file_name: str = 'none',
+        build: bool = False,
+        app_name: (str | None) = None,
+        testing: bool = False;
+
+    def init(
+        self: AppConfig,
+        code_folder: str,
+        file_name: str = 'none',
+        build: bool = False,
+        app_name: (str | None) = None,
+        testing: bool = False
+    ) -> None {
+        self.code_folder = code_folder;
+        self.file_name = file_name;
+        self.build = build;
+        self.app_name = app_name;
+        self.testing = testing;
+    }
+
+    def get_code_path(self: AppConfig) -> Path {
+        return Path(self.code_folder);
+    }
+}

jac_scale/abstractions/config/base_config.jac

@@ -0,0 +1,26 @@
+"""Base configuration class for jac_scale."""
+import from typing { Any }
+
+"""Base configuration class that all target-specific configs should inherit from."""
+class BaseConfig {
+    has app_name: str,
+        namespace: str = 'default';
+
+    def init(
+        self: BaseConfig, app_name: str = 'jaseci', namespace: str = 'default'
+    ) -> None {
+        self.app_name = app_name;
+        self.namespace = namespace;
+    }
+
+    def to_dict(self: BaseConfig) -> dict[str, Any] {
+        return {'app_name': self.app_name, 'namespace': self.namespace};
+    }
+
+    static def from_dict(cls: type, config: dict[str, Any]) -> BaseConfig {
+        return cls(
+            app_name=config.get('app_name', 'jaseci'),
+            namespace=config.get('namespace', 'default')
+        );
+    }
+}

jac_scale/abstractions/database_provider.jac

@@ -0,0 +1,51 @@
+"""Base database provider abstraction for jac_scale.
+
+All database provider implementations should inherit from this class.
+"""
+import from typing { Any }
+
+"""Base class for all database provider implementations."""
+class DatabaseProvider {
+    """Deploy the database service.
+
+    Args:
+        config: Database-specific configuration
+
+    Returns:
+        Dictionary with deployment information (e.g., service name, connection details)
+    """
+    def deploy(self: DatabaseProvider, config: dict[str, Any]) -> dict[str, Any];
+
+    """Get the connection string for the database.
+
+    Returns:
+        Connection string/URI for the database
+    """
+    def get_connection_string(self: DatabaseProvider) -> str;
+
+    """Check if the database is available/ready.
+
+    Returns:
+        True if database is available, False otherwise
+    """
+    def is_available(self: DatabaseProvider) -> bool;
+
+    """Clean up database resources.
+
+    This should remove all resources created by deploy().
+    """
+    def cleanup(self: DatabaseProvider) -> None;
+
+    """Get the init container configuration for the database.
+
+    Args:
+        app_name: Name of the application
+        wait_image: Docker image to use for the wait container
+
+    Returns:
+        Dictionary representing the init container, or None if not applicable.
+    """
+    def get_init_container(
+        self: DatabaseProvider, app_name: str, wait_image: str
+    ) -> (dict[(str, Any)] | None);
+}

jac_scale/abstractions/deployment_target.jac

@@ -0,0 +1,64 @@
+"""Base deployment target abstraction for jac_scale.
+
+All deployment target implementations should inherit from this class.
+"""
+import from jac_scale.abstractions.config.app_config { AppConfig }
+import from jac_scale.abstractions.config.base_config { BaseConfig }
+import from jac_scale.abstractions.models.deployment_result { DeploymentResult }
+import from jac_scale.abstractions.models.resource_status { ResourceStatusInfo }
+import from jac_scale.abstractions.database_provider { DatabaseProvider }
+import from jac_scale.abstractions.image_registry { ImageRegistry }
+import from jac_scale.abstractions.logger { Logger }
+
+"""Base class for all deployment target implementations."""
+class DeploymentTarget {
+    has config: BaseConfig,
+        logger: (Logger | None) = None,
+        database_providers: list[DatabaseProvider] = [],
+        image_registry: (ImageRegistry | None) = None;
+
+    """Deploy an application.
+
+    Args:
+        app_config: Application configuration
+
+    Returns:
+        Deployment result with success status and service URL
+    """
+    def deploy(self: DeploymentTarget, app_config: AppConfig) -> DeploymentResult;
+
+    """Destroy/remove a deployed application.
+
+    Args:
+        app_name: Name of the application to destroy
+    """
+    def destroy(self: DeploymentTarget, app_name: str) -> None;
+
+    """Get the status of a deployed application.
+
+    Args:
+        app_name: Name of the application
+
+    Returns:
+        Resource status information
+    """
+    def get_status(self: DeploymentTarget, app_name: str) -> ResourceStatusInfo;
+
+    """Scale an application to a specific number of replicas.
+
+    Args:
+        app_name: Name of the application
+        replicas: Number of replicas desired
+    """
+    def scale(self: DeploymentTarget, app_name: str, replicas: int) -> None;
+
+    """Get the service URL for a deployed application.
+
+    Args:
+        app_name: Name of the application
+
+    Returns:
+        Service URL or None if not available
+    """
+    def get_service_url(self: DeploymentTarget, app_name: str) -> (str | None);
+}

jac_scale/abstractions/image_registry.jac

@@ -0,0 +1,54 @@
+"""Base image registry abstraction for jac_scale.
+
+All image registry implementations should inherit from this class.
+"""
+
+"""Base class for all image registry implementations."""
+class ImageRegistry {
+    """Build a Docker image from code folder.
+
+    Args:
+        code_folder: Path to the code directory
+        image_name: Name for the image (optional)
+
+    Returns:
+        Full image name/tag
+    """
+    def build_image(
+        self: ImageRegistry, code_folder: str, image_name: (str | None) = None
+    ) -> str;
+
+    """Push an image to the registry.
+
+    Args:
+        image_name: Full image name to push
+    """
+    def push_image(self: ImageRegistry, image_name: str) -> None;
+
+    """Get the full image URL for a given image name.
+
+    Args:
+        image_name: Base image name
+
+    Returns:
+        Full image URL including registry
+    """
+    def get_image_url(self: ImageRegistry, image_name: str) -> str;
+
+    """Build and push an image in one operation.
+
+    Args:
+        code_folder: Path to the code directory
+        image_name: Name for the image (optional)
+
+    Returns:
+        Full image URL
+    """
+    def build_and_push(
+        self: ImageRegistry, code_folder: str, image_name: (str | None) = None
+    ) -> str {
+        image = self.build_image(code_folder, image_name);
+        self.push_image(image);
+        return self.get_image_url(image);
+    }
+}

jac_scale/abstractions/logger.jac

@@ -0,0 +1,20 @@
+"""Base logger abstraction for jac_scale.
+
+All logger implementations should inherit from this class.
+"""
+import from typing { Any }
+
+"""Base class for all logger implementations."""
+class Logger {
+    """Log an info message."""
+    def info(self: Logger, message: str, context: dict[str, Any] = {}) -> None;
+
+    """Log an error message."""
+    def error(self: Logger, message: str, context: dict[str, Any] = {}) -> None;
+
+    """Log a warning message."""
+    def warn(self: Logger, message: str, context: dict[str, Any] = {}) -> None;
+
+    """Log a debug message."""
+    def debug(self: Logger, message: str, context: dict[str, Any] = {}) -> None;
+}

jac_scale/abstractions/models/deployment_result.jac

@@ -0,0 +1,27 @@
+"""Deployment result model."""
+import from typing { Any }
+
+"""Result of a deployment operation."""
+class DeploymentResult {
+    has success: bool,
+        service_url: (str | None) = None,
+        message: (str | None) = None,
+        details: dict[str, Any] = {};
+
+    def init(
+        self: DeploymentResult,
+        success: bool,
+        service_url: (str | None) = None,
+        message: (str | None) = None,
+        details: dict[str, Any] = {}
+    ) -> None {
+        self.success = success;
+        self.service_url = service_url;
+        self.message = message;
+        self.details = details;
+    }
+
+    def is_successful(self: DeploymentResult) -> bool {
+        return self.success;
+    }
+}

jac_scale/abstractions/models/resource_status.jac

@@ -0,0 +1,38 @@
+"""Resource status model."""
+import from enum { Enum }
+
+"""Status of a deployed resource."""
+class ResourceStatus(Enum) {
+    has UNKNOWN: str = 'unknown',
+        PENDING: str = 'pending',
+        RUNNING: str = 'running',
+        FAILED: str = 'failed',
+        STOPPED: str = 'stopped';
+}
+
+"""Detailed resource status information."""
+class ResourceStatusInfo {
+    has status: ResourceStatus,
+        replicas: int = 0,
+        ready_replicas: int = 0,
+        message: (str | None) = None;
+
+    def init(
+        self: ResourceStatusInfo,
+        status: ResourceStatus,
+        replicas: int = 0,
+        ready_replicas: int = 0,
+        message: (str | None) = None
+    ) -> None {
+        self.status = status;
+        self.replicas = replicas;
+        self.ready_replicas = ready_replicas;
+        self.message = message;
+    }
+
+    def is_ready(self: ResourceStatusInfo) -> bool {
+        return self.status == ResourceStatus.RUNNING
+        and self.replicas > 0
+        and self.ready_replicas == self.replicas;
+    }
+}

jac_scale/config_loader.jac

@@ -0,0 +1,31 @@
+"""Configuration loader for Jac Scale.
+
+This module provides configuration access for the scale plugin.
+Configuration is loaded from jac.toml under [plugins.scale] section.
+
+Inherits from PluginConfigBase to eliminate boilerplate code.
+"""
+import from pathlib { Path }
+import from typing { Any }
+import from jaclang.project.plugin_config { PluginConfigBase }
+import os;
+
+"""Scale-specific configuration loader.
+
+Provides access to jwt, sso, database, kubernetes, and server configuration
+from the [plugins.scale] section of jac.toml.
+"""
+class JacScaleConfig(PluginConfigBase) {
+    override def get_plugin_name(self: JacScaleConfig) -> str;
+    override def get_default_config(self: JacScaleConfig) -> dict[str, Any];
+    def get_jwt_config(self: JacScaleConfig) -> dict[str, Any];
+    def get_sso_config(self: JacScaleConfig) -> dict[str, Any];
+    def get_database_config(self: JacScaleConfig) -> dict[str, Any];
+    def get_kubernetes_config(self: JacScaleConfig) -> dict[str, Any];
+    def get_server_config(self: JacScaleConfig) -> dict[str, Any];
+}
+
+glob _scale_config_instance: JacScaleConfig | None = None;
+
+def get_scale_config(project_dir: Path | None = None) -> JacScaleConfig;
+def reset_scale_config -> None;

jac_scale/context.jac

@@ -0,0 +1,14 @@
+import from dataclasses { MISSING }
+import from typing { Any }
+import from uuid { UUID }
+import from jaclang.pycore.constant { Constants as Con }
+import from jaclang.runtimelib.context { ExecutionContext }
+
+"""Jac Scale Execution Context with custom memory backend.
+
+Storage backend is configured via environment variables (e.g., MONGODB_URI),
+not per-context parameters.
+"""
+class JScaleExecutionContext(ExecutionContext) {
+    def init(self: JScaleExecutionContext) -> None;
+}

jac_scale/factories/database_factory.jac

@@ -0,0 +1,43 @@
+"""Factory for creating database providers."""
+import from typing { Any }
+import from jac_scale.abstractions.database_provider { DatabaseProvider }
+import from jac_scale.abstractions.deployment_target { DeploymentTarget }
+
+"""Factory for creating database provider instances."""
+class DatabaseProviderFactory {
+    """Create a database provider based on type.
+
+    Args:
+        provider_type: Type of database provider ('kubernetes_mongo', 'kubernetes_redis', etc.)
+        target: Deployment target instance (for target-specific providers)
+        config: Optional provider-specific configuration
+
+    Returns:
+        DatabaseProvider instance
+
+    Raises:
+        ValueError: If provider_type is not supported
+        NotImplementedError: If provider is not yet implemented
+    """
+    static def create(
+        provider_type: str,
+        target: (DeploymentTarget | None) = None,
+        config: (dict[str, Any] | None) = None
+    ) -> DatabaseProvider {
+        if provider_type == 'kubernetes_mongo' {
+            import from jac_scale.providers.database.kubernetes_mongo {
+                KubernetesMongoProvider
+            }
+            return KubernetesMongoProvider(target=target, config=config or {});
+        } elif provider_type == 'kubernetes_redis' {
+            import from jac_scale.providers.database.kubernetes_redis {
+                KubernetesRedisProvider
+            }
+            return KubernetesRedisProvider(target=target, config=config or {});
+        } elif provider_type == 'aws_documentdb' {
+            raise NotImplementedError("AWS DocumentDB provider not yet implemented") ;
+        } else {
+            raise ValueError(f"Unsupported database provider type: {provider_type}") ;
+        }
+    }
+}

jac_scale/factories/deployment_factory.jac

@@ -0,0 +1,43 @@
+"""Factory for creating deployment targets."""
+import from typing { Any }
+import from jac_scale.abstractions.deployment_target { DeploymentTarget }
+import from jac_scale.abstractions.config.base_config { BaseConfig }
+import from jac_scale.abstractions.logger { Logger }
+
+"""Factory for creating deployment target instances."""
+class DeploymentTargetFactory {
+    """Create a deployment target based on type.
+
+    Args:
+        target_type: Type of deployment target ('kubernetes', 'aws', 'gcp', etc.)
+        config: Configuration dictionary
+        logger: Optional logger instance
+
+    Returns:
+        DeploymentTarget instance
+
+    Raises:
+        ValueError: If target_type is not supported
+        NotImplementedError: If target is not yet implemented
+    """
+    static def create(
+        target_type: str, config: dict[str, Any], logger: (Logger | None) = None
+    ) -> DeploymentTarget {
+        if target_type == 'kubernetes' {
+            import from jac_scale.targets.kubernetes.kubernetes_target {
+                KubernetesTarget
+            }
+            import from jac_scale.targets.kubernetes.kubernetes_config {
+                KubernetesConfig
+            }
+            k8s_config = KubernetesConfig.from_dict(KubernetesConfig, config);
+            return KubernetesTarget(config=k8s_config, logger=logger);
+        } elif target_type == 'aws' {
+            raise NotImplementedError("AWS target not yet implemented") ;
+        } elif target_type == 'gcp' {
+            raise NotImplementedError("GCP target not yet implemented") ;
+        } else {
+            raise ValueError(f"Unsupported deployment target type: {target_type}") ;
+        }
+    }
+}

jac_scale/factories/registry_factory.jac

@@ -0,0 +1,32 @@
+"""Factory for creating image registries."""
+import from typing { Any }
+import from jac_scale.abstractions.image_registry { ImageRegistry }
+
+"""Factory for creating image registry instances."""
+class ImageRegistryFactory {
+    """Create an image registry based on type.
+
+    Args:
+        registry_type: Type of image registry ('dockerhub', 'ecr', 'gcr', etc.)
+        config: Configuration dictionary
+
+    Returns:
+        ImageRegistry instance
+
+    Raises:
+        ValueError: If registry_type is not supported
+        NotImplementedError: If registry is not yet implemented
+    """
+    static def create(registry_type: str, config: dict[str, Any]) -> ImageRegistry {
+        if registry_type == 'dockerhub' {
+            import from jac_scale.providers.registry.dockerhub { DockerHubRegistry }
+            return DockerHubRegistry(config=config);
+        } elif registry_type == 'ecr' {
+            raise NotImplementedError("AWS ECR registry not yet implemented") ;
+        } elif registry_type == 'gcr' {
+            raise NotImplementedError("GCP GCR registry not yet implemented") ;
+        } else {
+            raise ValueError(f"Unsupported image registry type: {registry_type}") ;
+        }
+    }
+}

jac_scale/factories/utility_factory.jac

@@ -0,0 +1,34 @@
+"""Factory for creating utility instances (loggers, monitoring, etc.)."""
+import from typing { Any }
+import from jac_scale.abstractions.logger { Logger }
+
+"""Factory for creating utility instances."""
+class UtilityFactory {
+    """Create a logger based on type.
+
+    Args:
+        logger_type: Type of logger ('standard', 'cloudwatch', 'elasticsearch', etc.)
+        config: Optional logger-specific configuration
+
+    Returns:
+        Logger instance
+
+    Raises:
+        ValueError: If logger_type is not supported
+        NotImplementedError: If logger is not yet implemented
+    """
+    static def create_logger(
+        logger_type: str = 'standard', config: (dict[str, Any] | None) = None
+    ) -> Logger {
+        if logger_type == 'standard' {
+            import from jac_scale.utilities.loggers.standard_logger { StandardLogger }
+            return StandardLogger(config=config or {});
+        } elif logger_type == 'cloudwatch' {
+            raise NotImplementedError("CloudWatch logger not yet implemented") ;
+        } elif logger_type == 'elasticsearch' {
+            raise NotImplementedError("Elasticsearch logger not yet implemented") ;
+        } else {
+            raise ValueError(f"Unsupported logger type: {logger_type}") ;
+        }
+    }
+}

jac_scale/impl/config_loader.impl.jac

@@ -0,0 +1,131 @@
+"""Implementation of Jac Scale configuration loader.
+
+This module provides the implementation for JacScaleConfig, which inherits
+from PluginConfigBase for common configuration loading functionality.
+
+The base class handles: init, load, get_jac_config, deep_merge, get_section.
+This file only implements plugin-specific methods.
+"""
+import from pathlib { Path }
+import from typing { Any }
+import os;
+
+"""Get the plugin section name for scale."""
+impl JacScaleConfig.get_plugin_name(self: JacScaleConfig) -> str {
+    return "scale";
+}
+
+"""Get default configuration structure for scale."""
+impl JacScaleConfig.get_default_config(self: JacScaleConfig) -> dict[str, Any] {
+    return {
+        'jwt': {'secret': 'supersecretkey', 'algorithm': 'HS256', 'exp_delta_days': 7},
+        'sso': {
+            'host': 'http://localhost:8000/sso',
+            'google': {'client_id': '', 'client_secret': ''}
+        },
+        'database': {
+            'mongodb_uri': None,
+            'redis_url': None,
+            'shelf_db_path': '.jac/data/anchor_store.db'
+        },
+        'kubernetes': {
+            'app_name': 'jaseci',
+            'docker_image_name': '',
+            'docker_username': '',
+            'docker_password': '',
+            'namespace': 'default',
+            'container_port': 8000,
+            'node_port': 30001,
+            'mongodb_enabled': True,
+            'redis_enabled': True,
+            # Resource requests/limits
+            'cpu_request': None,
+            'cpu_limit': None,
+            'memory_request': None,
+            'memory_limit': None,
+            # Probe timings
+            'readiness_initial_delay': 10,
+            'readiness_period': 20,
+            'liveness_initial_delay': 10,
+            'liveness_period': 20,
+            'liveness_failure_threshold': 80
+        },
+        'server': {'port': 8000, 'host': '0.0.0.0'}
+    };
+}
+
+"""Get JWT configuration from jac.toml."""
+impl JacScaleConfig.get_jwt_config(self: JacScaleConfig) -> dict[str, Any] {
+    config = self.load();
+    jwt_config = config.get('jwt', {});
+    return {
+        'secret': jwt_config.get('secret', 'supersecretkey'),
+        'algorithm': jwt_config.get('algorithm', 'HS256'),
+        'exp_delta_days': int(jwt_config.get('exp_delta_days', 7))
+    };
+}
+
+"""Get SSO configuration from jac.toml."""
+impl JacScaleConfig.get_sso_config(self: JacScaleConfig) -> dict[str, Any] {
+    config = self.load();
+    sso_config = config.get('sso', {});
+    google_config = sso_config.get('google', {});
+    return {
+        'host': sso_config.get('host', 'http://localhost:8000/sso'),
+        'google': {
+            'client_id': google_config.get('client_id', ''),
+            'client_secret': google_config.get('client_secret', '')
+        }
+    };
+}
+
+"""Get database configuration from jac.toml."""
+impl JacScaleConfig.get_database_config(self: JacScaleConfig) -> dict[str, Any] {
+    config = self.load();
+    db_config = config.get('database', {});
+    return {
+        'mongodb_uri': os.environ.get('MONGODB_URI') or db_config.get('mongodb_uri'),
+        'redis_url': os.environ.get('REDIS_URL') or db_config.get('redis_url'),
+        'shelf_db_path': db_config.get('shelf_db_path', '.jac/data/anchor_store.db')
+    };
+}
+
+"""Get Kubernetes configuration from jac.toml."""
+impl JacScaleConfig.get_kubernetes_config(self: JacScaleConfig) -> dict[str, Any] {
+    config = self.load();
+    k8s_config = config.get('kubernetes', {});
+    # Handle docker_image_name default (needs app_name)
+    if not k8s_config.get('docker_image_name') {
+        app_name = k8s_config.get('app_name', 'jaseci');
+        k8s_config['docker_image_name'] = f"{app_name}:latest";
+    }
+    # Convert to dict using KubernetesConfig.from_dict() which handles all defaults
+    import from jac_scale.targets.kubernetes.kubernetes_config { KubernetesConfig }
+    k8s_config_obj = KubernetesConfig.from_dict(KubernetesConfig, k8s_config);
+    return k8s_config_obj.to_dict();
+}
+
+"""Get server configuration from jac.toml."""
+impl JacScaleConfig.get_server_config(self: JacScaleConfig) -> dict[str, Any] {
+    config = self.load();
+    server_config = config.get('server', {});
+    return {
+        'port': int(server_config.get('port', 8000)),
+        'host': server_config.get('host', '0.0.0.0')
+    };
+}
+
+"""Get or create the global JacScaleConfig instance."""
+impl get_scale_config(project_dir: Path | None = None) -> JacScaleConfig {
+    global _scale_config_instance;
+    if _scale_config_instance is None {
+        _scale_config_instance = JacScaleConfig(project_dir);
+    }
+    return _scale_config_instance;
+}
+
+"""Reset the global config instance (useful for testing)."""
+impl reset_scale_config -> None {
+    global _scale_config_instance;
+    _scale_config_instance = None;
+}

jac_scale/impl/context.impl.jac

@@ -0,0 +1,24 @@
+"""Initialize JScaleExecutionContext.
+
+Storage backend is configured via environment variables (e.g., MONGODB_URI),
+not per-context parameters.
+"""
+
+impl JScaleExecutionContext.init(self: JScaleExecutionContext) -> None {
+    import from jac_scale.memory_hierarchy { ScaleTieredMemory }
+    import from jaclang.pycore.constructs { Anchor, NodeAnchor, Root }
+    # ScaleTieredMemory gets storage config from environment variables
+    self.mem = ScaleTieredMemory();
+    self.reports: list[Any] = [];
+    self.custom: Any = MISSING;
+    system_root_anchor: (Anchor | None) = self.mem.get(UUID(Con.SUPER_ROOT_UUID));
+    if not isinstance(system_root_anchor, NodeAnchor) {
+        system_root_anchor = Root().__jac__;
+        system_root_anchor.id = UUID(Con.SUPER_ROOT_UUID);
+        self.mem.put(system_root_anchor);
+    }
+    self.system_root = system_root_anchor;
+    # Default user_root and entry_node to system_root
+    self.user_root = self.system_root;
+    self.entry_node = self.system_root;
+}