mirrorneuron-cli 1.2.6__tar.gz → 1.2.7__tar.gz

{mirrorneuron_cli-1.2.6/mirrorneuron_cli.egg-info → mirrorneuron_cli-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirrorneuron-cli
-Version: 1.2.6
+Version: 1.2.7
 Summary: MirrorNeuron CLI
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3

{mirrorneuron_cli-1.2.6 → mirrorneuron_cli-1.2.7/mirrorneuron_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mirrorneuron-cli
-Version: 1.2.6
+Version: 1.2.7
 Summary: MirrorNeuron CLI
 License-Expression: MIT
 Classifier: Programming Language :: Python :: 3

{mirrorneuron_cli-1.2.6 → mirrorneuron_cli-1.2.7}/mirrorneuron_cli.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ mn_cli/libs/run_manifest.py
 mn_cli/libs/runtime_health.py
 mn_cli/libs/schedule_cmds.py
 mn_cli/libs/service_cmds.py
+mn_cli/libs/skill_dependencies.py
 mn_cli/libs/skill_runtime.py
 mn_cli/libs/sys_cmds.py
 mn_cli/libs/ui.py
@@ -66,6 +67,7 @@ tests/test_docker_network_integration.py
 tests/test_job_cmds.py
 tests/test_main.py
 tests/test_model_cmds.py
+tests/test_repo_hygiene.py
 tests/test_resource_cmds.py
 tests/test_run_cmds.py
 tests/test_run_helpers.py

{mirrorneuron_cli-1.2.6 → mirrorneuron_cli-1.2.7}/mn_cli/libs/blueprint_cmds.py

@@ -3,7 +3,6 @@ import copy
 import json
 import shutil
 import subprocess
-import sys
 import time
 from pathlib import Path
 from typing import Annotated, Any, Optional
@@ -59,6 +58,9 @@ from mn_cli.libs.model_cmds import (
     remove_model_ref as _remove_model_ref,
 )
 from mn_sdk.runtime_config import resolve_mn_home
+from mn_sdk.blueprint_support.python_workflow_bundle import (
+    generate_python_workflow_bundle_from_blueprint_dir,
+)
 from mn_sdk import (
     cluster_provided_model as _cluster_provided_model,
     docker_model_name as _docker_model_name,
@@ -81,16 +83,6 @@ human_app = typer.Typer(
 _PATCH_COMPAT = (subprocess, _git_checkout, _git_fetch)
 
 
-def _inject_local_blueprint_support_path() -> None:
-    repo_root = Path(
-        os.getenv("MN_WORKSPACE_ROOT")
-        or Path(__file__).resolve().parents[3]
-    ).expanduser()
-    candidate = repo_root / "mn-skills" / "blueprint_support_skill" / "src"
-    if candidate.is_dir() and str(candidate) not in sys.path:
-        sys.path.insert(0, str(candidate))
-
-
 @blueprint_app.callback()
 def blueprint_callback(
     ctx: typer.Context,
@@ -147,11 +139,6 @@ def _prepare_blueprint_bundle_for_run(
 
 def _generate_python_source_bundle(blueprint_dir: Path, output_dir: Path) -> Path:
     _load_observability_api()
-    _inject_local_blueprint_support_path()
-    from mn_blueprint_support.python_workflow_bundle import (
-        generate_python_workflow_bundle_from_blueprint_dir,
-    )
-
     return generate_python_workflow_bundle_from_blueprint_dir(
         blueprint_dir,
         output_dir,

{mirrorneuron_cli-1.2.6 → mirrorneuron_cli-1.2.7}/mn_cli/libs/blueprint_observability.py

@@ -1,47 +1,33 @@
 from __future__ import annotations
 
 import json
-from pathlib import Path
-import sys
 import time
 from typing import Any, Callable, Optional
 
 import typer
+from mn_sdk.blueprint_support import make_run_id
+from mn_sdk.blueprint_support.observability import (
+    acknowledge_human_notice,
+    list_pending_human_requests,
+    list_runs,
+    load_run,
+    read_human_events,
+    read_run_events,
+    read_run_logs,
+    read_run_resources,
+    read_run_stream_records,
+    record_human_response,
+)
+from mn_sdk.blueprint_support.web_ui import write_static_run_report
 
 from mn_cli.shared import console
 
 
 def load_observability_api() -> tuple[Callable[..., list[dict[str, Any]]], Callable[..., dict[str, Any]], Callable[..., list[dict[str, Any]]]]:
-    _ensure_blueprint_support_path()
-    try:
-        from mn_blueprint_support.observability import list_runs, load_run, read_run_events
-    except ModuleNotFoundError:
-        console.print(
-            "[red]Blueprint observability support is unavailable. "
-            "Install the blueprint support package or run from the monorepo checkout.[/red]"
-        )
-        raise typer.Exit(1)
     return list_runs, load_run, read_run_events
 
 
 def load_observability_tools() -> dict[str, Callable[..., Any]]:
-    _ensure_blueprint_support_path()
-    try:
-        from mn_blueprint_support.observability import (
-            acknowledge_human_notice,
-            list_pending_human_requests,
-            read_human_events,
-            read_run_logs,
-            read_run_resources,
-            read_run_stream_records,
-            record_human_response,
-        )
-    except ModuleNotFoundError:
-        console.print(
-            "[red]Blueprint observability support is unavailable. "
-            "Install the blueprint support package or run from the monorepo checkout.[/red]"
-        )
-        raise typer.Exit(1)
     return {
         "acknowledge_human_notice": acknowledge_human_notice,
         "list_pending_human_requests": list_pending_human_requests,
@@ -53,28 +39,12 @@ def load_observability_tools() -> dict[str, Callable[..., Any]]:
     }
 
 
-def _ensure_blueprint_support_path() -> None:
-    repo_root = Path(__file__).resolve().parents[3]
-    support_src = repo_root / "mn-skills" / "blueprint_support_skill" / "src"
-    if support_src.exists() and str(support_src) not in sys.path:
-        sys.path.insert(0, str(support_src))
-
-
 def load_web_ui_api() -> Callable[..., Any]:
-    load_observability_api()
-    try:
-        from mn_blueprint_support.web_ui import write_static_run_report
-    except ModuleNotFoundError:
-        console.print("[red]Blueprint web UI support is unavailable.[/red]")
-        raise typer.Exit(1)
     return write_static_run_report
 
 
 def make_blueprint_run_id(blueprint_id: str) -> str:
     try:
-        load_observability_api()
-        from mn_blueprint_support import make_run_id
-
         return make_run_id(blueprint_id)
     except Exception:
         import uuid

{mirrorneuron_cli-1.2.6 → mirrorneuron_cli-1.2.7}/mn_cli/libs/event_relay.py

@@ -2,25 +2,9 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from mn_cli.shared import client
-
-
-def _ensure_blueprint_support_path() -> None:
-    import os
-    import sys
-
-    repo_root = Path(
-        os.getenv("MN_WORKSPACE_ROOT")
-        or Path(__file__).resolve().parents[3]
-    ).expanduser()
-    support_src = repo_root / "mn-skills" / "blueprint_support_skill" / "src"
-    if support_src.is_dir() and str(support_src) not in sys.path:
-        sys.path.insert(0, str(support_src))
+from mn_sdk.blueprint_support.event_relay import build_parser, run_event_relay
 
-
-_ensure_blueprint_support_path()
-
-from mn_blueprint_support.event_relay import build_parser, run_event_relay
+from mn_cli.shared import client
 
 
 def main(argv: list[str] | None = None) -> int:

{mirrorneuron_cli-1.2.6 → mirrorneuron_cli-1.2.7}/mn_cli/libs/run_cmds.py

@@ -8,6 +8,7 @@ import signal
 import socket
 import subprocess
 import sys
+import tempfile
 import time
 import urllib.parse
 from pathlib import Path
@@ -43,12 +44,14 @@ from mn_cli.libs.run_manifest import (
     runtime_web_ui_support_payloads_for_manifest,
     run_mode_label as _run_mode_label,
     stage_blueprint_support_payloads_for_manifest,
+    stage_skill_dependency_payloads_for_manifest,
     stage_skill_runtime_support_payloads_for_manifest,
     stage_local_input_payloads_for_manifest,
     stage_upload_path_payloads_for_manifest,
     with_shared_run_store_config as _with_shared_run_store_config,
 )
 from mn_cli.libs.skill_runtime import validate_skill_runtime_requirements
+from mn_cli.libs.skill_dependencies import gar_requirements_text
 from mn_cli.libs.workflow_validation import (
     _is_workflow_manifest,
     _manifest_workflow_id,
@@ -59,6 +62,7 @@ from mn_cli.libs.blueprint_observability import (
     make_blueprint_run_id as _make_blueprint_run_id,
 )
 from mn_cli.libs.blueprint_resources import cleanup_blueprint_host_hooks
+from mn_cli.server_cmds import ensure_context_engine_runtime
 from mn_cli.shared import console, client, logger
 from mn_cli.terminal import use_progress
 from mn_cli.error_handler import handle_cli_error
@@ -75,6 +79,7 @@ from mn_sdk import (
     validate_service_spec_issues,
     workflow_progress_snapshot,
 )
+from mn_sdk.context_engine import blueprint_requires_context_engine
 from mn_sdk.runtime_config import default_runs_root
 
 FINAL_STATUSES = {"completed", "failed", "cancelled"}
@@ -84,6 +89,10 @@ POST_LAUNCH_SCRIPT = Path("scripts/post-launch.sh")
 DEFAULT_BLUEPRINT_WEB_UI_PORT_START = 61000
 DEFAULT_BLUEPRINT_WEB_UI_PORT_END = 61049
 DETACHED_AFTER_INTERRUPT_MESSAGE = "Detached from workflow UI. Job is still running."
+CONTEXT_ENGINE_EXPECTATION = (
+    "This blueprint uses context memory. First launch may download the context model "
+    "and start the Membrane context engine; keep Docker running and be patient."
+)
 _HELPER_COMPAT = (
     _add_mn_llm_aliases,
     _blueprint_runtime_environment,
@@ -93,6 +102,13 @@ _HELPER_COMPAT = (
 )
 
 
+def _print_launch_progress(label: str, detail: str | None = None) -> None:
+    if detail:
+        console.print(f"[cyan]Launch:[/cyan] {label} - {detail}")
+    else:
+        console.print(f"[cyan]Launch:[/cyan] {label}")
+
+
 def fetch_and_save_results(job_id: str, data: dict = None):
     log_dir = Path(f"/tmp/mn_{job_id}")
     log_dir.mkdir(parents=True, exist_ok=True)
@@ -218,6 +234,48 @@ def _manifest_config(manifest: dict[str, Any]) -> dict[str, Any]:
     return {}
 
 
+def _ensure_context_engine_for_run_if_needed(
+    bundle_dir: Path,
+    manifest: dict[str, Any],
+    *,
+    env_overrides: Optional[dict[str, str]] = None,
+    config_overrides: Optional[dict[str, Any]] = None,
+    force: bool = False,
+) -> dict[str, str] | None:
+    config = load_blueprint_config(bundle_dir, config_overrides=config_overrides)
+    effective_env = os.environ.copy()
+    effective_env.update(
+        {
+            str(key): str(value)
+            for key, value in (env_overrides or {}).items()
+            if value is not None
+        }
+    )
+    if not blueprint_requires_context_engine(manifest, config, env=effective_env):
+        return None
+
+    console.print(f"[cyan]{CONTEXT_ENGINE_EXPECTATION}[/cyan]")
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        TimeElapsedColumn(),
+        console=console,
+        disable=not use_progress(),
+    ) as progress:
+        task = progress.add_task(
+            "[cyan]Preparing context memory: checking Membrane and Docker Model Runner...",
+            total=None,
+        )
+        summary = ensure_context_engine_runtime(force=force)
+        progress.update(task, description="[green]Context memory is ready.")
+    console.print(
+        f"[green]Context memory ready:[/green] {summary.get('service', 'membrane-context-engine')} "
+        f"using {summary.get('model', 'configured model')}"
+    )
+    logger.info("Context engine runtime ensured for %s: %s", bundle_dir, summary)
+    return summary
+
+
 def _expand_user_output_path(value: str) -> Path:
     text = str(value or "").strip()
     home = (
@@ -1423,6 +1481,7 @@ def _stage_bundle_payloads(
         payloads.update(runtime_web_ui_support_payloads_for_manifest(manifest_dict))
     stage_blueprint_support_payloads_for_manifest(manifest_dict, payloads, bundle_dir=bundle_dir)
     stage_skill_runtime_support_payloads_for_manifest(manifest_dict, payloads, bundle_dir=bundle_dir)
+    stage_skill_dependency_payloads_for_manifest(manifest_dict, payloads, bundle_dir=bundle_dir)
     return payloads
 
 
@@ -1514,6 +1573,10 @@ def run_bundle(
             submission_metadata,
             config_overrides=config_overrides,
         )
+        _print_launch_progress(
+            "Check runtime resources",
+            "confirming the runtime can satisfy this blueprint before submission.",
+        )
         _validate_manifest_hardware_or_exit(
             manifest_dict,
             force=force,
@@ -1536,6 +1599,10 @@ def run_bundle(
                 config_overrides=config_overrides,
             )
         if not force:
+            _print_launch_progress(
+                "Validate inputs and dependencies",
+                "checking services, models, local inputs, and non-hard requirements.",
+            )
             _validate_manifest_services_or_exit(
                 bundle_dir,
                 manifest_dict,
@@ -1558,6 +1625,10 @@ def run_bundle(
             console.print(
                 "[yellow]Validation skipped because --force was provided; service checks, model checks, input checks, and non-hard runtime requirements will be bypassed for this run.[/yellow]"
             )
+        _print_launch_progress(
+            "Package workflow",
+            "staging workflow files, local inputs, runtime helpers, and output wiring.",
+        )
         manifest_dict = prepare_manifest_for_submission(
             bundle_dir,
             manifest_dict,
@@ -1583,6 +1654,14 @@ def run_bundle(
             )
             return
 
+        _ensure_context_engine_for_run_if_needed(
+            bundle_dir,
+            manifest_dict,
+            env_overrides=env_overrides,
+            config_overrides=config_overrides,
+            force=force,
+        )
+
         prepared_submission = prepare_job_submission(
             manifest_dict,
             payloads,
@@ -1599,6 +1678,10 @@ def run_bundle(
             else None
         )
         submitted_run_dir = blueprint_run_dir
+        _print_launch_progress(
+            "Submit runtime job",
+            "handing the prepared bundle to MirrorNeuron core.",
+        )
         job_id = client.submit_job(manifest, payloads, force=force)
         submitted_job_id = job_id
         log_writer = JobLogWriter(job_id, run_dir=blueprint_run_dir)
@@ -1883,9 +1966,14 @@ def _prepare_openshell_custom_images(
         if source_path is None:
             continue
 
-        config["from"] = _build_openshell_from_image(
-            source_path, node.get("node_id") or "openshell"
-        )
+        build_source = _openshell_skill_dependency_context(source_path, manifest_dict)
+        try:
+            config["from"] = _build_openshell_from_image(
+                build_source, node.get("node_id") or "openshell"
+            )
+        finally:
+            if build_source != source_path:
+                shutil.rmtree(build_source, ignore_errors=True)
 
 
 def _openshell_gateway_endpoint() -> str:
@@ -1981,6 +2069,30 @@ def _openshell_local_from_path(bundle_dir: Path, source: Any) -> Path | None:
     return None
 
 
+def _openshell_skill_dependency_context(source_path: Path, manifest: dict[str, Any]) -> Path:
+    requirements_text = gar_requirements_text(manifest)
+    if not requirements_text:
+        return source_path
+
+    source_root = source_path.parent if source_path.is_file() else source_path
+    temp_context = Path(tempfile.mkdtemp(prefix=f"mn-openshell-skill-deps-{source_root.name}."))
+    shutil.copytree(source_root, temp_context, dirs_exist_ok=True)
+    dockerfile = temp_context / "Dockerfile"
+    requirements = temp_context / "__mn_skill_dependencies" / "requirements.txt"
+    requirements.parent.mkdir(parents=True, exist_ok=True)
+    requirements.write_text(requirements_text, encoding="utf-8")
+    dockerfile.write_text(
+        dockerfile.read_text(encoding="utf-8").rstrip()
+        + "\n\n"
+        + "COPY __mn_skill_dependencies/requirements.txt /tmp/mn-skill-dependencies/requirements.txt\n"
+        + "RUN if [ -s /tmp/mn-skill-dependencies/requirements.txt ]; then \\\n"
+        + "      python3 -m pip install --break-system-packages --no-cache-dir -r /tmp/mn-skill-dependencies/requirements.txt; \\\n"
+        + "    fi\n",
+        encoding="utf-8",
+    )
+    return temp_context
+
+
 def _build_openshell_from_image(source_path: Path, node_id: Any) -> str:
     console.print(
         f"[yellow]Building OpenShell sandbox image for {node_id} from {source_path}...[/yellow]"
@@ -2451,7 +2563,7 @@ def _start_background_event_relay_if_needed(
     command = [
         sys.executable,
         "-m",
-        "mn_blueprint_support.event_relay",
+        "mn_sdk.blueprint_support.event_relay",
         "--job-id",
         job_id,
         "--run-dir",
@@ -2464,7 +2576,6 @@ def _start_background_event_relay_if_needed(
 
     env = os.environ.copy()
     env["MN_RUN_EVENT_RELAY_CHILD"] = "1"
-    _inject_local_blueprint_support_pythonpath(env)
     with open(log_path, "a", encoding="utf-8") as relay_log:
         process = subprocess.Popen(
             command,
@@ -2598,7 +2709,7 @@ def _web_ui_registration_module(
 
     adapter = str(output.get("adapter") or web_ui.get("kind") or "").lower()
     if adapter == "gradio" and output.get("auto_generate", True) is not False:
-        return "mn_blueprint_support.gradio_dashboard"
+        return "mn_sdk.blueprint_support.gradio_dashboard"
     return None
 
 
@@ -2764,21 +2875,6 @@ def _launch_blueprint_web_ui_command(
         )
 
 
-def _inject_local_blueprint_support_pythonpath(env: dict[str, str]) -> None:
-    repo_root = Path(
-        os.getenv("MN_WORKSPACE_ROOT")
-        or Path(__file__).resolve().parents[3]
-    ).expanduser()
-    support_src = repo_root / "mn-skills" / "blueprint_support_skill" / "src"
-    if not support_src.is_dir():
-        return
-    current = env.get("PYTHONPATH")
-    paths = [str(support_src)]
-    if current:
-        paths.append(current)
-    env["PYTHONPATH"] = os.pathsep.join(paths)
-
-
 def _web_ui_bind_host(output: dict[str, Any], env_overrides: dict[str, str]) -> str:
     for value in (
         env_overrides.get("MN_BLUEPRINT_WEB_UI_BIND_HOST"),