Pipeline.Safety.SafetyManager (pipeline v0.0.1)

@type execution_context() :: %{
  nesting_depth: non_neg_integer(),
  pipeline_id: String.t(),
  parent_context: execution_context() | nil,
  step_count: non_neg_integer(),
  start_time: DateTime.t(),
  workspace_dir: String.t() | nil
}

safety_config()

@type safety_config() :: %{
  max_depth: non_neg_integer(),
  max_total_steps: non_neg_integer(),
  memory_limit_mb: non_neg_integer(),
  timeout_seconds: non_neg_integer(),
  workspace_enabled: boolean(),
  cleanup_on_error: boolean()
}

safety_result()

@type safety_result() :: :ok | {:error, String.t()}

Functions

check_safety(pipeline_id, context)

@spec check_safety(String.t(), execution_context()) :: safety_result()

Perform comprehensive safety checks before executing a nested pipeline.

Parameters

pipeline_id: The ID of the pipeline about to be executed
context: The current execution context
config: Safety configuration (optional)

Returns

:ok if all safety checks pass
{:error, message} if any safety check fails

Examples

iex> context = %{nesting_depth: 2, pipeline_id: "test", parent_context: nil, step_count: 5, start_time: DateTime.utc_now(), workspace_dir: nil}
iex> Pipeline.Safety.SafetyManager.check_safety("child", context)
:ok

check_safety(pipeline_id, context, config)

@spec check_safety(String.t(), execution_context(), safety_config()) ::
  safety_result()

cleanup_execution(context)

@spec cleanup_execution(execution_context()) :: execution_context()

Clean up resources and perform safety cleanup after execution.

Parameters

context: Execution context to clean up
config: Safety configuration (optional)

Returns

Cleaned execution context

cleanup_execution(context, config)

@spec cleanup_execution(execution_context(), safety_config()) :: execution_context()

create_safe_context(pipeline_id)

@spec create_safe_context(String.t()) :: execution_context()

Create execution context for a nested pipeline with safety tracking.

Parameters

pipeline_id: The ID of the pipeline
parent_context: The parent execution context (optional)
step_count: Number of steps in the pipeline (default: 0)
config: Safety configuration (optional)

Returns

New execution context with safety tracking

create_safe_context(pipeline_id, parent_context)

@spec create_safe_context(String.t(), execution_context() | nil) ::
  execution_context()

create_safe_context(pipeline_id, parent_context, step_count)

@spec create_safe_context(String.t(), execution_context() | nil, non_neg_integer()) ::
  execution_context()

create_safe_context(pipeline_id, parent_context, step_count, config)

@spec create_safe_context(
  String.t(),
  execution_context() | nil,
  non_neg_integer(),
  safety_config()
) :: execution_context()

default_config()

@spec default_config() :: safety_config()

Get default safety configuration.

Returns

Default safety configuration map

handle_safety_violation(error, context)

@spec handle_safety_violation(String.t(), execution_context()) :: String.t()

Handle safety violations and perform appropriate cleanup.

Parameters

error: The safety error that occurred
context: Current execution context
config: Safety configuration (optional)

Returns

Formatted error with context information

handle_safety_violation(error, context, config)

@spec handle_safety_violation(String.t(), execution_context(), safety_config()) ::
  String.t()

merge_config(user_config \\ %{})

@spec merge_config(map()) :: safety_config()

Merge user configuration with defaults.

Parameters

user_config: User-provided configuration (optional)

Returns

Complete safety configuration

monitor_execution(context)

@spec monitor_execution(execution_context()) :: safety_result()

Monitor ongoing execution and check for safety violations.

Parameters

context: Current execution context
config: Safety configuration (optional)

Returns

:ok if execution is within safety limits
{:error, message} if safety limits exceeded

monitor_execution(context, config)

@spec monitor_execution(execution_context(), safety_config()) :: safety_result()