autobots-devtools-shared-lib 0.2.1__tar.gz → 0.2.3a2__tar.gz

{autobots_devtools_shared_lib-0.2.1 → autobots_devtools_shared_lib-0.2.3a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobots-devtools-shared-lib
-Version: 0.2.1
+Version: 0.2.3a2
 Summary: Shared library functions to be used for all autobots projects
 License: MIT
 Author: Pralhad

{autobots_devtools_shared_lib-0.2.1 → autobots_devtools_shared_lib-0.2.3a2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "autobots-devtools-shared-lib"
-version = "0.2.1"
+version = "0.2.3-alpha.2"
 description = "Shared library functions to be used for all autobots projects"
 readme = "README.md"
 authors = [

autobots_devtools_shared_lib-0.2.3a2/src/autobots_devtools_shared_lib/common/jenkins/__init__.py

@@ -0,0 +1,26 @@
+# ABOUTME: Jenkins pipeline trigger package — config, loader, and tool generation.
+# ABOUTME: Part of the common layer; usable by any dynagent-based application.
+
+from autobots_devtools_shared_lib.common.jenkins.config import (
+    JenkinsAuthConfig,
+    JenkinsConfig,
+    JenkinsParameterConfig,
+    JenkinsPipelineConfig,
+    JenkinsPollingConfig,
+)
+from autobots_devtools_shared_lib.common.jenkins.loader import load_jenkins_config
+from autobots_devtools_shared_lib.common.jenkins.tools import (
+    create_jenkins_tools,
+    register_pipeline_tools,
+)
+
+__all__ = [
+    "JenkinsAuthConfig",
+    "JenkinsConfig",
+    "JenkinsParameterConfig",
+    "JenkinsPipelineConfig",
+    "JenkinsPollingConfig",
+    "create_jenkins_tools",
+    "load_jenkins_config",
+    "register_pipeline_tools",
+]

autobots_devtools_shared_lib-0.2.3a2/src/autobots_devtools_shared_lib/common/jenkins/builtin_tools.py

@@ -0,0 +1,89 @@
+# ABOUTME: Built-in generic Jenkins observability tools.
+# ABOUTME: Provides get_jenkins_build_status and get_jenkins_console_log.
+# ABOUTME: Call set_jenkins_config() once at startup before these tools are invoked.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import requests
+from langchain.tools import tool
+
+from autobots_devtools_shared_lib.common.jenkins.http_utils import get_auth
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
+
+if TYPE_CHECKING:
+    from autobots_devtools_shared_lib.common.jenkins.config import JenkinsConfig
+
+logger = get_logger(__name__)
+
+_config: JenkinsConfig | None = None
+
+
+def set_jenkins_config(config: JenkinsConfig) -> None:
+    """Store the Jenkins config for use by the builtin tools at call time."""
+    global _config
+    _config = config
+
+
+def _get_config() -> JenkinsConfig:
+    if _config is None:
+        raise RuntimeError("Jenkins builtin tools used before set_jenkins_config() was called")
+    return _config
+
+
+@tool
+def get_jenkins_build_status(job_name: str, build_number: int | None = None) -> str:
+    """Get the current status of a Jenkins build.
+
+    Returns a concise string with job name, build number,
+    status (SUCCESS / FAILURE / IN_PROGRESS), and build URL.
+    Omit build_number to check the latest build.
+    """
+    config = _get_config()
+    base_url = config.base_url.rstrip("/")
+    auth = get_auth(config)
+    if build_number is None:
+        api_url = f"{base_url}/job/{job_name}/lastBuild/api/json"
+    else:
+        api_url = f"{base_url}/job/{job_name}/{build_number}/api/json"
+    try:
+        resp = requests.get(api_url, auth=auth, timeout=30)
+        resp.raise_for_status()
+        data = resp.json()
+        number = data.get("number")
+        building = data.get("building", False)
+        result = data.get("result")
+        url = data.get("url", "")
+        status = "IN_PROGRESS" if (building or result is None) else str(result).upper()
+    except requests.RequestException as exc:
+        logger.exception(f"Error getting build status for '{job_name}'")
+        return f"Error getting build status: {exc}"
+    else:
+        return f"job={job_name} build={number} status={status} url={url}"
+
+
+@tool
+def get_jenkins_console_log(job_name: str, build_number: int | None = None, start: int = 0) -> str:
+    """Retrieve the console log output for a Jenkins build.
+
+    Returns the log text from the given byte offset.
+    Use start=0 (default) for the full log.
+    Omit build_number to use the latest build.
+    Useful for diagnosing pipeline failures.
+    """
+    config = _get_config()
+    base_url = config.base_url.rstrip("/")
+    auth = get_auth(config)
+    if build_number is None:
+        log_url = f"{base_url}/job/{job_name}/lastBuild/logText/progressiveText?start={start}"
+    else:
+        log_url = f"{base_url}/job/{job_name}/{build_number}/logText/progressiveText?start={start}"
+    try:
+        resp = requests.get(log_url, auth=auth, timeout=30)
+        resp.raise_for_status()
+    except requests.RequestException as exc:
+        logger.exception(f"Error getting console log for '{job_name}'")
+        return f"Error getting console log: {exc}"
+    else:
+        return resp.text

autobots_devtools_shared_lib-0.2.3a2/src/autobots_devtools_shared_lib/common/jenkins/config.py

@@ -0,0 +1,105 @@
+# ABOUTME: Pydantic models for jenkins.yaml configuration.
+# ABOUTME: Defines auth, polling, parameter, tool, and top-level Jenkins config models.
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+
+
+class JenkinsAuthConfig(BaseModel):
+    """Credentials resolved from environment variables at runtime."""
+
+    username_env: str = Field(
+        default="JENKINS_USERNAME",
+        description="Name of the env var holding the Jenkins username",
+    )
+    token_env: str = Field(
+        default="JENKINS_API_TOKEN",
+        description="Name of the env var holding the Jenkins API token",
+    )
+
+
+class JenkinsPollingConfig(BaseModel):
+    """Controls whether and how long to wait for a triggered build to complete."""
+
+    wait_for_completion: bool = Field(
+        default=True,
+        description="Whether to block until the build finishes",
+    )
+    poll_interval_seconds: int = Field(
+        default=10,
+        description="Seconds to wait between build-status polls",
+    )
+    max_wait_seconds: int = Field(
+        default=300,
+        description="Maximum seconds to wait before giving up",
+    )
+    queue_max_retries: int = Field(
+        default=5,
+        description="Max attempts to resolve a build number from the Jenkins queue",
+    )
+    queue_retry_delay_seconds: int = Field(
+        default=2,
+        description="Seconds to wait between queue-item polls",
+    )
+
+
+class JenkinsParameterConfig(BaseModel):
+    """A single parameter that will be forwarded as a query string to Jenkins."""
+
+    type: str = Field(
+        default="string",
+        description="Parameter type: 'string', 'boolean', or 'integer'",
+    )
+    description: str = Field(
+        default="",
+        description="LLM-facing hint describing what value to provide",
+    )
+    required: bool = Field(
+        default=True,
+        description="Whether the LLM must always supply this parameter",
+    )
+
+
+class JenkinsPipelineConfig(BaseModel):
+    """Configuration for a single Jenkins pipeline entry.
+
+    The framework registers this as a LangChain tool named ``{key}_tool``,
+    so pipeline keys in jenkins.yaml should not carry a ``_tool`` suffix.
+    """
+
+    uri: str = Field(
+        description="Relative URI path for the Jenkins pipeline, e.g. /job/my-job/buildWithParameters"
+    )
+    description: str = Field(
+        default="",
+        description="LLM-facing docstring describing what this pipeline does",
+    )
+    parameters: dict[str, JenkinsParameterConfig] = Field(
+        default_factory=dict,
+        description="Parameters forwarded as query strings to Jenkins",
+    )
+    polling: JenkinsPollingConfig | None = Field(
+        default=None,
+        description="Per-pipeline polling overrides; falls back to global polling config when None",
+    )
+
+
+class JenkinsConfig(BaseModel):
+    """Top-level Jenkins configuration loaded from jenkins.yaml."""
+
+    base_url: str = Field(description="Jenkins base URL, e.g. https://jenkins.example.com")
+    auth: JenkinsAuthConfig = Field(
+        default_factory=JenkinsAuthConfig,
+        description="Authentication configuration (env var names for credentials)",
+    )
+    polling: JenkinsPollingConfig = Field(
+        default_factory=JenkinsPollingConfig,
+        description="Global polling defaults, overridable per pipeline",
+    )
+    pipelines: dict[str, JenkinsPipelineConfig] = Field(
+        description=(
+            "Named pipeline definitions. Each key is the pipeline identifier; "
+            "the framework registers it as a LangChain tool named ``{key}_tool``."
+        )
+    )

autobots_devtools_shared_lib-0.2.3a2/src/autobots_devtools_shared_lib/common/jenkins/http_utils.py

@@ -0,0 +1,147 @@
+# ABOUTME: Low-level HTTP helpers for Jenkins API interactions.
+# ABOUTME: Handles auth resolution, queue polling, build completion waiting, and URL parsing.
+
+from __future__ import annotations
+
+import os
+import time
+from typing import TYPE_CHECKING, Any
+
+import requests
+
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
+
+if TYPE_CHECKING:
+    from autobots_devtools_shared_lib.common.jenkins.config import (
+        JenkinsConfig,
+        JenkinsPollingConfig,
+    )
+
+logger = get_logger(__name__)
+
+
+def get_auth(config: JenkinsConfig) -> tuple[str, str] | None:
+    """Resolve Basic Auth credentials from environment variables.
+
+    Returns a (username, token) tuple, or None if either env var is unset.
+    """
+    username = os.getenv(config.auth.username_env, "")
+    token = os.getenv(config.auth.token_env, "")
+    if username and token:
+        return (username, token)
+    logger.warning(
+        f"Jenkins auth env vars '{config.auth.username_env}' / '{config.auth.token_env}' "
+        "not set — requests will be unauthenticated"
+    )
+    return None
+
+
+def poll_queue_for_build_number(
+    queue_location: str,
+    polling: JenkinsPollingConfig,
+    auth: tuple[str, str] | None,
+) -> dict[str, Any]:
+    """Poll the Jenkins queue API until a build number is assigned.
+
+    Returns a dict with keys: status ('success' | 'queued' | 'error'),
+    message, build_number, build_url.
+    """
+    if not queue_location:
+        msg = "No queue location returned — build may not have triggered"
+        logger.error(msg)
+        return {"status": "error", "message": msg, "build_number": None, "build_url": None}
+
+    time.sleep(1)
+    queue_api_url = f"{queue_location}api/json"
+    logger.info(f"Polling Jenkins queue: {queue_api_url}")
+
+    for attempt in range(polling.queue_max_retries):
+        try:
+            resp = requests.get(queue_api_url, auth=auth, timeout=30)
+            resp.raise_for_status()
+            data = resp.json()
+            executable = data.get("executable")
+            if executable:
+                build_number = executable.get("number")
+                build_url = executable.get("url")
+                logger.info(f"Build #{build_number} assigned: {build_url}")
+                return {
+                    "status": "success",
+                    "message": f"Build #{build_number} assigned",
+                    "build_number": build_number,
+                    "build_url": build_url,
+                }
+            if attempt < polling.queue_max_retries - 1:
+                logger.debug(
+                    f"Queue attempt {attempt + 1}/{polling.queue_max_retries}: "
+                    f"build not yet assigned, waiting {polling.queue_retry_delay_seconds}s"
+                )
+                time.sleep(polling.queue_retry_delay_seconds)
+        except requests.RequestException as exc:
+            logger.exception(f"Queue poll error (attempt {attempt + 1})")
+            if attempt < polling.queue_max_retries - 1:
+                time.sleep(polling.queue_retry_delay_seconds)
+            else:
+                return {
+                    "status": "error",
+                    "message": f"Queue poll failed after {polling.queue_max_retries} attempts: {exc}",
+                    "build_number": None,
+                    "build_url": None,
+                }
+
+    return {
+        "status": "queued",
+        "message": f"Build queued but not yet assigned after {polling.queue_max_retries} attempts",
+        "build_number": None,
+        "build_url": None,
+    }
+
+
+def wait_for_build(
+    base_url: str,
+    job_name: str,
+    build_number: int,
+    polling: JenkinsPollingConfig,
+    auth: tuple[str, str] | None,
+) -> str:
+    """Poll the build API until the result is non-null or the timeout is reached."""
+    elapsed = 0
+    while elapsed < polling.max_wait_seconds:
+        api_url = f"{base_url}/job/{job_name}/{build_number}/api/json"
+        try:
+            resp = requests.get(api_url, auth=auth, timeout=30)
+            resp.raise_for_status()
+            data = resp.json()
+            building = data.get("building", False)
+            result = data.get("result")
+            build_url = data.get("url", "")
+            if not building and result is not None:
+                logger.info(f"Build #{build_number} completed: {result}")
+                return f"job={job_name} build={build_number} result={result} url={build_url}"
+            logger.debug(
+                f"Build #{build_number} in progress; "
+                f"waiting {polling.poll_interval_seconds}s (elapsed={elapsed}s)"
+            )
+            time.sleep(polling.poll_interval_seconds)
+            elapsed += polling.poll_interval_seconds
+        except requests.RequestException as exc:
+            logger.exception(f"Build poll error for {job_name}#{build_number}")
+            return f"Error polling build status: {exc}"
+
+    return (
+        f"Timeout: build #{build_number} for job '{job_name}' "
+        f"did not complete within {polling.max_wait_seconds}s"
+    )
+
+
+def extract_job_name_from_url(url: str) -> str:
+    """Extract the Jenkins job name from a relative URL.
+
+    Example: /job/create-workspace/buildWithParameters → 'create-workspace'
+    """
+    parts = [p for p in url.split("/") if p]
+    try:
+        job_idx = parts.index("job")
+        return parts[job_idx + 1]
+    except (ValueError, IndexError):
+        return url

autobots_devtools_shared_lib-0.2.3a2/src/autobots_devtools_shared_lib/common/jenkins/loader.py

@@ -0,0 +1,47 @@
+# ABOUTME: Loads jenkins.yaml from the same config directory as agents.yaml.
+# ABOUTME: Returns None silently when jenkins.yaml is absent (feature is opt-in).
+
+from __future__ import annotations
+
+import yaml
+
+from autobots_devtools_shared_lib.common.jenkins.config import JenkinsConfig
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
+
+logger = get_logger(__name__)
+
+
+def load_jenkins_config() -> JenkinsConfig | None:
+    """Load and validate jenkins.yaml from the active config directory.
+
+    Reads from the same directory as agents.yaml (controlled by
+    DYNAGENT_CONFIG_ROOT_DIR). Returns None if jenkins.yaml is absent so
+    callers do not need to handle the optional file specially.
+
+    Returns:
+        Validated JenkinsConfig or None if the file does not exist.
+
+    Raises:
+        yaml.YAMLError: If the file contains invalid YAML.
+        pydantic.ValidationError: If the YAML structure does not match the schema.
+    """
+    from autobots_devtools_shared_lib.dynagent.agents.agent_config_utils import get_config_dir
+
+    config_dir = get_config_dir()
+    jenkins_path = config_dir / "jenkins.yaml"
+
+    if not jenkins_path.exists():
+        logger.debug(
+            f"No jenkins.yaml found at {jenkins_path}; Jenkins tools will not be registered"
+        )
+        return None
+
+    logger.info(f"Loading Jenkins config from {jenkins_path}")
+    with open(jenkins_path) as f:  # noqa: PTH123
+        raw = yaml.safe_load(f)
+
+    config = JenkinsConfig.model_validate(raw["jenkins_config"])
+    logger.info(
+        f"Loaded Jenkins config with {len(config.pipelines)} pipeline(s): {list(config.pipelines)}"
+    )
+    return config

autobots_devtools_shared_lib-0.2.3a2/src/autobots_devtools_shared_lib/common/jenkins/tools.py

@@ -0,0 +1,167 @@
+# ABOUTME: Generates LangChain StructuredTools from JenkinsConfig at startup.
+# ABOUTME: One tool is created per pipeline entry; tool name = "{pipeline_key}_tool".
+# ABOUTME: register_pipeline_tools() is the single entry point for auto-registration.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import requests
+from langchain_core.tools import StructuredTool
+from pydantic import BaseModel, Field, create_model
+
+from autobots_devtools_shared_lib.common.jenkins.builtin_tools import (
+    get_jenkins_build_status,
+    get_jenkins_console_log,
+    set_jenkins_config,
+)
+from autobots_devtools_shared_lib.common.jenkins.http_utils import (
+    extract_job_name_from_url,
+    get_auth,
+    poll_queue_for_build_number,
+    wait_for_build,
+)
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
+
+if TYPE_CHECKING:
+    from autobots_devtools_shared_lib.common.jenkins.config import (
+        JenkinsConfig,
+        JenkinsPipelineConfig,
+    )
+
+logger = get_logger(__name__)
+
+_PYTHON_TYPE_MAP: dict[str, type] = {
+    "string": str,
+    "str": str,
+    "boolean": bool,
+    "bool": bool,
+    "integer": int,
+    "int": int,
+    "float": float,
+    "number": float,
+}
+
+
+def _build_args_schema(tool_name: str, pipeline_cfg: JenkinsPipelineConfig) -> type[BaseModel]:
+    """Build a dynamic Pydantic model from a pipeline's parameters.
+
+    Required parameters get a plain Field; optional ones get ``type | None`` with default None.
+    """
+    field_definitions: dict[str, Any] = {}
+    for param_name, param_cfg in pipeline_cfg.parameters.items():
+        py_type = _PYTHON_TYPE_MAP.get(param_cfg.type.lower(), str)
+        if param_cfg.required:
+            field_definitions[param_name] = (py_type, Field(description=param_cfg.description))
+        else:
+            field_definitions[param_name] = (
+                py_type | None,
+                Field(default=None, description=param_cfg.description),
+            )
+    return create_model(f"{tool_name}_args", **field_definitions)
+
+
+def _make_trigger_fn(
+    tool_name: str,
+    pipeline_cfg: JenkinsPipelineConfig,
+    config: JenkinsConfig,
+) -> Any:
+    """Return a closure that triggers the Jenkins pipeline and handles completion polling."""
+    effective_polling = pipeline_cfg.polling or config.polling
+    full_url = config.base_url.rstrip("/") + pipeline_cfg.uri
+
+    def trigger(**kwargs: Any) -> str:
+        auth = get_auth(config)
+        query_params = {k: v for k, v in kwargs.items() if v is not None}
+        logger.info(
+            f"Triggering Jenkins tool '{tool_name}': POST {full_url} params={list(query_params)}"
+        )
+        try:
+            response = requests.post(full_url, params=query_params, auth=auth, timeout=30)
+            response.raise_for_status()
+        except requests.RequestException as exc:
+            logger.exception(f"Jenkins trigger failed for '{tool_name}'")
+            return f"Error triggering Jenkins pipeline: {exc}"
+
+        queue_location = response.headers.get("Location", "")
+        build_info = poll_queue_for_build_number(queue_location, effective_polling, auth)
+
+        if build_info["status"] != "success":
+            return build_info["message"]
+
+        build_number: int = build_info["build_number"]
+        build_url: str = build_info["build_url"]
+
+        if not effective_polling.wait_for_completion:
+            logger.info(f"Fire-and-forget: build #{build_number} triggered at {build_url}")
+            return f"Build #{build_number} triggered: {build_url}"
+
+        job_name = extract_job_name_from_url(pipeline_cfg.uri)
+        return wait_for_build(config.base_url, job_name, build_number, effective_polling, auth)
+
+    trigger.__name__ = tool_name
+    return trigger
+
+
+def create_jenkins_tools(config: JenkinsConfig) -> list[Any]:
+    """Generate LangChain StructuredTools from a JenkinsConfig.
+
+    For each entry in ``config.pipelines`` a StructuredTool is created whose
+    name is ``{pipeline_key}_tool`` (e.g. pipeline key ``create_workspace``
+    → tool name ``create_workspace_tool``).
+
+    Args:
+        config: Validated JenkinsConfig loaded from jenkins.yaml.
+
+    Returns:
+        List of pipeline StructuredTools ready for ``register_usecase_tools()``.
+        The builtin observability tools are default tools and not included here.
+    """
+
+    tools: list[Any] = []
+
+    for pipeline_name, pipeline_cfg in config.pipelines.items():
+        tool_name = f"{pipeline_name}_tool"
+        args_schema = _build_args_schema(tool_name, pipeline_cfg)
+        trigger_fn = _make_trigger_fn(tool_name, pipeline_cfg, config)
+        description = pipeline_cfg.description or f"Trigger Jenkins pipeline: {pipeline_cfg.uri}"
+
+        tools.append(
+            StructuredTool.from_function(
+                func=trigger_fn,
+                name=tool_name,
+                description=description,
+                args_schema=args_schema,
+            )
+        )
+        logger.info(f"Registered Jenkins tool '{tool_name}' → {pipeline_cfg.uri}")
+
+    return tools
+
+
+def register_pipeline_tools() -> list[Any]:
+    """Load jenkins.yaml and return dynamic pipeline tools.
+
+    Returns an empty list when jenkins.yaml is absent or unreadable.
+    Callers are responsible for caching the result — this function always
+    reads from disk on each invocation.
+    """
+    try:
+        from autobots_devtools_shared_lib.common.jenkins.loader import load_jenkins_config
+
+        logger.info("Loading Jenkins pipeline tools")
+        config = load_jenkins_config()
+        if config:
+            set_jenkins_config(config)
+            pipeline_tools = create_jenkins_tools(config)
+            # Builtins require a valid config (set inside create_jenkins_tools via set_jenkins_config).
+            # Include them here so they are only available when Jenkins is actually configured.
+            all_tools = [get_jenkins_build_status, get_jenkins_console_log, *pipeline_tools]
+            logger.info(
+                f"Loaded {len(pipeline_tools)} pipeline tool(s) + 2 builtin Jenkins tools"
+                " from jenkins.yaml"
+            )
+            return all_tools
+    except Exception:
+        logger.exception("Failed to load Jenkins pipeline tools — continuing without them")
+    return []

{autobots_devtools_shared_lib-0.2.1 → autobots_devtools_shared_lib-0.2.3a2}/src/autobots_devtools_shared_lib/common/servers/fileserver/app.py

@@ -136,6 +136,9 @@ def list_files(body: ListFilesBody) -> dict[str, Any]:
     """List files under path. When workspace_context is set, path is under that workspace."""
     set_session_id(body.session_id or "default_session_id")
     logger.info("listFiles called path=%s", body.path)
+    # Resolve the workspace root (config.root or config.root / workspace_base_path)
+    workspace_root = _path_under_root(body.workspace_context, None)
+    # Resolve the base directory to walk, under the workspace root
     base = _path_under_root(body.workspace_context, body.path)
     if not base.exists():
         logger.warning("listFiles path not found path=%s", base)
@@ -148,8 +151,10 @@ def list_files(body: ListFilesBody) -> dict[str, Any]:
         for name in filenames:
             full = Path(root) / name
             try:
-                rel = full.relative_to(config.root)
+                # Return paths relative to the workspace root (after the workspace context folder)
+                rel = full.relative_to(workspace_root)
             except ValueError:
+                # Skip any files not under the workspace root
                 continue
             files.append(str(rel).replace("\\", "/"))
     logger.info("listFiles success path=%s count=%s", body.path, len(files))

{autobots_devtools_shared_lib-0.2.1 → autobots_devtools_shared_lib-0.2.3a2}/src/autobots_devtools_shared_lib/dynagent/__init__.py

@@ -5,6 +5,9 @@
 # UI streaming helpers live in dynagent.ui to avoid pulling Chainlit for
 # batch/invoke-only use.
 
+from autobots_devtools_shared_lib.common.jenkins.config import JenkinsConfig, JenkinsPipelineConfig
+from autobots_devtools_shared_lib.common.jenkins.loader import load_jenkins_config
+from autobots_devtools_shared_lib.common.jenkins.tools import create_jenkins_tools
 from autobots_devtools_shared_lib.common.utils.format_utils import output_format_converter
 from autobots_devtools_shared_lib.dynagent.agents.agent_config_utils import get_batch_enabled_agents
 from autobots_devtools_shared_lib.dynagent.agents.agent_meta import AgentMeta
@@ -33,15 +36,19 @@ __all__ = [
     "BatchResult",
     "Dynagent",
     "DynagentSettings",
+    "JenkinsConfig",
+    "JenkinsPipelineConfig",
     "LLMProvider",
     "RecordResult",
     "ainvoke_agent",
     "batch_invoker",
     "create_base_agent",
+    "create_jenkins_tools",
     "get_batch_enabled_agents",
     "get_dynagent_settings",
     "invoke_agent",
     "lm",
+    "load_jenkins_config",
     "output_format_converter",
     "register_usecase_tools",
     "set_dynagent_settings",

{autobots_devtools_shared_lib-0.2.1 → autobots_devtools_shared_lib-0.2.3a2}/src/autobots_devtools_shared_lib/dynagent/config/dynagent_settings.py

@@ -43,11 +43,6 @@ class DynagentSettings(BaseSettings):
     )
 
     # Workspace settings
-    # TODO: Remove these settings
-    workspace_base: Path = Field(default=Path("workspace"), description="Workspace base directory")
-    schema_base: Path = Field(
-        default=Path("schemas"), description="Base directory for JSON schemas"
-    )
     dynagent_config_root_dir: Path = Field(
         default=Path("configs"),
         description="Base directory for agent configuration files",

{autobots_devtools_shared_lib-0.2.1 → autobots_devtools_shared_lib-0.2.3a2}/src/autobots_devtools_shared_lib/dynagent/tools/state_tools.py

@@ -1,5 +1,5 @@
 # ABOUTME: State management tools for the dynagent workflow.
-# ABOUTME: Provides command helpers, workspace file I/O, and handoff logic.
+# ABOUTME: Provides command helpers and handoff logic.
 
 from typing import Any
 
@@ -8,7 +8,6 @@ from langchain.tools import ToolRuntime, tool
 from langgraph.types import Command
 
 from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
-from autobots_devtools_shared_lib.dynagent.config.dynagent_settings import get_dynagent_settings
 from autobots_devtools_shared_lib.dynagent.models.state import Dynagent
 
 logger = get_logger(__name__)
@@ -47,34 +46,14 @@ def transition_cmd(message: str, tool_call_id: str, new_agent: str, **updates: A
     )
 
 
-# --- Workspace file I/O (core logic extracted for testability) ---
-
-
-def _do_write_file(session_id: str, filename: str, content: str) -> str:
-    """Core write logic."""
-    workspace_base = get_dynagent_settings().workspace_base
-    path = workspace_base / session_id / filename
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(content)
-    logger.info(f"Wrote workspace file: {path}")
-    return f"Successfully wrote {filename}"
-
-
-def _do_read_file(session_id: str, filename: str) -> str:
-    """Core read logic."""
-    workspace_base = get_dynagent_settings().workspace_base
-    path = workspace_base / session_id / filename
-    if not path.exists():
-        return f"Error: file not found: workspace/{session_id}/{filename}"
-    return path.read_text()
-
-
 # --- Handoff validation (extracted for testability) ---
 
 
 def _validate_handoff(next_agent: str) -> str | None:
     """Validate agent name against config. Returns error string or None."""
-    from autobots_devtools_shared_lib.dynagent.agents.agent_config_utils import get_agent_list
+    from autobots_devtools_shared_lib.dynagent.agents.agent_config_utils import (
+        get_agent_list,
+    )
 
     valid = get_agent_list()
     if next_agent not in valid:

{autobots_devtools_shared_lib-0.2.1 → autobots_devtools_shared_lib-0.2.3a2}/src/autobots_devtools_shared_lib/dynagent/tools/tool_registry.py

@@ -1,8 +1,10 @@
 # ABOUTME: Central registry of all dynagent-layer tools plus usecase-registered pools.
 # ABOUTME: Default tools live here; use-cases (e.g. BRO) register their own at startup.
 
+import threading
 from typing import Any
 
+from autobots_devtools_shared_lib.common.observability.logging_utils import get_logger
 from autobots_devtools_shared_lib.common.tools.context_tools import (
     clear_context_tool,
     get_context_tool,
@@ -20,10 +22,21 @@ from autobots_devtools_shared_lib.common.tools.fserver_client_tools import (
 )
 from autobots_devtools_shared_lib.dynagent.tools.state_tools import get_agent_list, handoff
 
+logger = get_logger(__name__)
+
 # --- Module-level usecase storage (populated by register_* at startup) ---
 
 _USECASE_TOOLS: list[Any] = []
 
+# --- Jenkins pipeline tool cache (None = not yet loaded) ---
+# Loaded once on first get_jenkins_usecase_tools() call.
+# [] means jenkins.yaml absent/unreadable — permanently cached, never retried.
+# Double-checked locking guards against concurrent initialisation during I/O
+# (CPython releases the GIL on file reads, making the race real).
+
+_jenkins_tools_cache: list[Any] | None = None
+_jenkins_tools_lock = threading.Lock()
+
 
 # --- Default (dynagent-layer) tools ---
 
@@ -47,6 +60,28 @@ def get_default_tools() -> list[Any]:
     ]
 
 
+def get_jenkins_usecase_tools() -> list[Any]:
+    """Return Jenkins pipeline tools discovered from jenkins.yaml.
+
+    Thread-safe via double-checked locking:
+    - Outer check avoids lock acquisition on every call once initialised (fast path).
+    - Inner check inside the lock prevents duplicate initialisation when two threads
+      race through the outer check simultaneously during I/O (GIL released on reads).
+    Returns [] permanently if jenkins.yaml is absent or unreadable.
+    """
+    logger.info("Getting Jenkins pipeline tools")
+    global _jenkins_tools_cache
+    if _jenkins_tools_cache is None:  # 1st check — no lock (fast path)
+        with _jenkins_tools_lock:  # acquire lock
+            if _jenkins_tools_cache is None:  # 2nd check — inside lock (safe)
+                from autobots_devtools_shared_lib.common.jenkins.tools import (
+                    register_pipeline_tools,
+                )
+
+                _jenkins_tools_cache = register_pipeline_tools()
+    return _jenkins_tools_cache
+
+
 # --- Usecase registration (called once per use-case at startup) ---
 
 
@@ -64,12 +99,15 @@ def get_usecase_tools() -> list[Any]:
 
 
 def get_all_tools() -> list[Any]:
-    """Return default + usecase tools (the full pool passed to the agent)."""
-    return get_default_tools() + get_usecase_tools()
+    """Return default + jenkins pipeline + usecase tools. Pure reader."""
+    logger.info("Getting all tools")
+    return get_default_tools() + get_jenkins_usecase_tools() + get_usecase_tools()
 
 
 # --- Test-isolation helpers (private; used only by fixtures) ---
 
 
 def _reset_usecase_tools() -> None:
+    global _jenkins_tools_cache
     _USECASE_TOOLS.clear()
+    _jenkins_tools_cache = None

{autobots_devtools_shared_lib-0.2.1 → autobots_devtools_shared_lib-0.2.3a2}/src/autobots_devtools_shared_lib/dynagent/ui/default_ui.py

@@ -47,7 +47,7 @@ logger = get_logger(__name__)
 @cl.on_chat_start
 async def start():
     """Create the base agent once and store it in the Chainlit session."""
-    agent = create_base_agent(initial_agent_name="coordinator")  # pyright: ignore[reportCallIssue]
+    agent = create_base_agent()  # pyright: ignore[reportCallIssue]
     cl.user_session.set("agent", agent)
     await cl.Message(content="Hello, how can I help you today?").send()