maestro-install 0.1.6__py3-none-any.whl

care_install/__init__.py

@@ -0,0 +1,10 @@
+"""maestro-install — bootstrap a CARE workspace from a single `uvx` command.
+
+The package ships the existing top-level `wizard.py`, `prepare.py`,
+`services.py`, `repos.yaml`, and `bin/` tree (re-rooted under
+`care_install/` at build time — see `[tool.hatch.build.targets.wheel.force-include]`
+in pyproject.toml). The `maestro-install` console script entry point lives in
+`care_install.wizard:main`.
+"""
+
+__version__ = "0.1.1"

care_install/bin/c-dev

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# c-dev: dispatcher for the CARE workspace docker stacks.
+# Usage:
+#   c-dev <service> <action> [extra args forwarded to docker compose]
+#     service: all | mem | plat
+#     action:  up | down | ps | logs | restart
+#
+# Environment:
+#   CARE_WORKSPACE   prepared workspace dir
+#                    (default: ~/Development/care-workspace)
+#
+# The wrapper scripts in the same directory (c-up, c-mem-logs, ...)
+# all delegate here.
+
+set -euo pipefail
+
+# Resolve the real script dir, following any symlinks the user installed
+# under ~/.local/bin or similar.
+src="${BASH_SOURCE[0]}"
+while [ -L "$src" ]; do
+  dir="$(cd -P "$(dirname "$src")" >/dev/null && pwd)"
+  src="$(readlink "$src")"
+  [[ $src != /* ]] && src="$dir/$src"
+done
+SCRIPT_DIR="$(cd -P "$(dirname "$src")" >/dev/null && pwd)"
+REPO_DIR="$(dirname "$SCRIPT_DIR")"
+
+WORKSPACE="${CARE_WORKSPACE:-$HOME/Development/care-workspace}"
+
+usage() {
+  cat >&2 <<'EOF'
+usage: c-dev <service> <action> [args...]
+  service: all | mem | plat
+  action:  up | down | ps | logs | restart
+
+env:
+  CARE_WORKSPACE   path to the prepared workspace
+                   (default: ~/Development/care-workspace)
+EOF
+  exit 2
+}
+
+[ $# -ge 2 ] || usage
+service="$1"
+action="$2"
+shift 2
+
+case "$service" in
+  all)  only=() ;;
+  mem)  only=(--only gigaevo-memory) ;;
+  plat) only=(--only gigaevo-platform) ;;
+  *)    echo "c-dev: unknown service '$service'" >&2; usage ;;
+esac
+
+case "$action" in
+  up|down|ps|logs|restart) ;;
+  *) echo "c-dev: unknown action '$action'" >&2; usage ;;
+esac
+
+exec uv run "$REPO_DIR/services.py" "$WORKSPACE" "$action" "${only[@]}" "$@"

care_install/bin/c-down

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" all down "$@"

care_install/bin/c-logs

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" all logs "$@"

care_install/bin/c-mage

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# c-mage: print MAGE workspace status.
+# MAGE (carl-mage) is an in-process Python library, not a docker stack,
+# so there are no up/down/logs commands for it — CARE imports it directly.
+# Use this script to jump-check the repo state.
+
+set -euo pipefail
+
+WORKSPACE="${CARE_WORKSPACE:-$HOME/Development/care-workspace}"
+MAGE_DIR="$WORKSPACE/carl-mage"
+
+if [ ! -d "$MAGE_DIR" ]; then
+  echo "carl-mage not found at $MAGE_DIR" >&2
+  echo "Run \`make prepare DIR=$WORKSPACE\` first." >&2
+  exit 1
+fi
+
+echo "MAGE: $MAGE_DIR"
+echo "Note: MAGE runs in-process inside CARE. No docker stack."
+echo
+git -C "$MAGE_DIR" status --short --branch

care_install/bin/c-mem-down

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" mem down "$@"

care_install/bin/c-mem-logs

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" mem logs "$@"

care_install/bin/c-mem-ps

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" mem ps "$@"

care_install/bin/c-mem-restart

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" mem restart "$@"

care_install/bin/c-mem-up

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" mem up "$@"

care_install/bin/c-plat-down

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" plat down "$@"

care_install/bin/c-plat-logs

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" plat logs "$@"

care_install/bin/c-plat-ps

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" plat ps "$@"

care_install/bin/c-plat-restart

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" plat restart "$@"

care_install/bin/c-plat-up

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" plat up "$@"

care_install/bin/c-ps

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" all ps "$@"

care_install/bin/c-restart

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" all restart "$@"

care_install/bin/c-up

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+exec "$(dirname "$0")/c-dev" all up "$@"

care_install/bin/c-ws

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+# c-ws: print the resolved CARE workspace path.
+# Useful for `cd "$(c-ws)"` from any directory.
+echo "${CARE_WORKSPACE:-$HOME/Development/care-workspace}"

care_install/bin/care

@@ -0,0 +1,43 @@
+#!/usr/bin/env bash
+# `care` system shim — installed by care-install/wizard.py.
+#
+# Reads ~/.config/care-install/state to find out:
+#   CARE_WORKSPACE   workspace dir (holds .env)
+#   CARE_MODE        "uvx" or "local"
+#   CARE_LOCAL_PATH  local clone of the care repo (only when MODE=local)
+#
+# Then it cd's into the workspace so `care`'s dotenv loader picks up
+# `<workspace>/.env`, and dispatches to either `uvx maestro-care` or
+# `uv run --project <care-clone> care`.
+
+set -euo pipefail
+
+STATE_FILE="${CARE_INSTALL_STATE:-$HOME/.config/care-install/state}"
+
+if [[ ! -f "$STATE_FILE" ]]; then
+  echo "care: $STATE_FILE not found — run the wizard:" >&2
+  echo "  uv run /path/to/care-install/wizard.py" >&2
+  exit 1
+fi
+
+# shellcheck disable=SC1090
+source "$STATE_FILE"
+
+: "${CARE_WORKSPACE:?CARE_WORKSPACE missing from $STATE_FILE}"
+: "${CARE_MODE:?CARE_MODE missing from $STATE_FILE}"
+
+cd "$CARE_WORKSPACE"
+
+case "$CARE_MODE" in
+  uvx)
+    exec uvx --from maestro-care care "$@"
+    ;;
+  local)
+    : "${CARE_LOCAL_PATH:?CARE_LOCAL_PATH missing from $STATE_FILE}"
+    exec uv run --project "$CARE_LOCAL_PATH" care "$@"
+    ;;
+  *)
+    echo "care: unknown CARE_MODE='$CARE_MODE' in $STATE_FILE" >&2
+    exit 1
+    ;;
+esac

care_install/build_runner_slim.py

@@ -0,0 +1,161 @@
+"""Build a slim variant of gigaevo-platform's runner-api image.
+
+The upstream runner Dockerfile pulls ~2 GB of ML deps (lightautoml, catboost,
+bert_score, evaluate, statsmodels) and their transitive CUDA wheels. The
+chain-experiment path that CARE drives only needs ROUGE-L scoring +
+mmar-carl + httpx, so the heavy classical-ML / NLP-eval deps add 15+ minutes
+to a cold build that CARE-driven workflows never pay back.
+
+This script generates ``runner_api/Dockerfile.slim`` next to the upstream
+Dockerfile (without touching the upstream file) and invokes
+``docker build --file Dockerfile.slim``. It mirrors
+``scripts/build_runner_image.sh`` so the rest of the pre_compose pipeline
+(generate_runner_pool_compose.py, RUNNER_IMAGE_NAME wiring) is unchanged.
+
+Invoked from ``care-install/repos.yaml`` pre_compose. Slim is the default
+build; ``CARE_RUNNER_VARIANT=full`` (wizard.py's ``--full`` flag) opts back
+into the heavy upstream build instead.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+# Deps the chain-experiment path actually uses. Anything else from the
+# upstream pip-install block is dropped in slim mode.
+SLIM_KEEP = {"gigaevo-memory", "scikit-learn", "rouge_score", "mmar-carl", "httpx"}
+
+# Deps to skip entirely (upstream lists them on continuation lines).
+SLIM_DROP = {"lightautoml", "catboost", "evaluate", "bert_score"}
+
+
+def _patch_dockerfile(src: Path) -> str:
+    """Return upstream Dockerfile text with the heavy pip install stripped.
+
+    The replacement keeps the same RUN structure (single layer) so
+    BuildKit reuses earlier layers unchanged. We rewrite only the
+    ``uv pip install ... lightautoml catboost ...`` block and drop the
+    follow-up ``statsmodels`` install.
+    """
+    text = src.read_text(encoding="utf-8")
+
+    # Replace the heavy multi-package install + statsmodels follow-up
+    # + pip-check as a single span so the resulting RUN ends cleanly
+    # (no orphan trailing ``\`` that would silently merge with the
+    # next RUN). Anchor: the second ``uv pip install`` line (the one
+    # that lists lightautoml/catboost/…) through the ``pip … check ||
+    # true`` line. We don't touch the first ``uv pip install`` block
+    # that installs the local gigaevo-core editable package.
+    pattern = re.compile(
+        r"uv pip install --python /opt/gigaevo-core/\.venv/bin/python \\\s*\n"
+        r"(?:[ \t]+[^\n]*\n)+?"
+        r"[ \t]+\"httpx>=0\.25\.0\";[ \t]*\\?\s*\n"
+        r"(?:[ \t]*PY=/opt/gigaevo-core/\.venv/bin/python;[ \t]*\\\s*\n"
+        r"[ \t]*uv pip install --python \"\$PY\" \"statsmodels==[\d.]+\";[ \t]*\\\s*\n"
+        r"[ \t]*\"\$PY\" -m pip --disable-pip-version-check check \|\| true\s*\n)?",
+        re.MULTILINE,
+    )
+    slim_block = (
+        "uv pip install --python /opt/gigaevo-core/.venv/bin/python \\\n"
+        "      gigaevo-memory \\\n"
+        "      scikit-learn \\\n"
+        "      rouge_score \\\n"
+        "      \"mmar-carl>=0.1.0\" \\\n"
+        "      \"httpx>=0.25.0\"\n"
+    )
+    new_text, n = pattern.subn(slim_block, text, count=1)
+    if n != 1:
+        raise RuntimeError(
+            "build_runner_slim: couldn't locate upstream pip-install block "
+            "in Dockerfile — upstream layout changed. Inspect "
+            f"{src} and update the regex."
+        )
+
+    banner = (
+        "# Auto-generated by care-install/care_install/build_runner_slim.py.\n"
+        "# Slim variant: drops lightautoml, catboost, bert_score, evaluate,\n"
+        "# statsmodels (and their CUDA wheel closure). Do not edit by hand —\n"
+        "# re-run `wizard.py --action up` (slim is the default).\n"
+    )
+    return banner + new_text
+
+
+def _source_env_file(env_file: Path) -> dict[str, str]:
+    """Parse the .env file the upstream build script sources. We only
+    need RUNNER_IMAGE_NAME and the optional GIGAEVO_CORE_* knobs."""
+    env: dict[str, str] = {}
+    if not env_file.exists():
+        return env
+    for raw in env_file.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        value = value.strip().strip('"').strip("'")
+        env[key.strip()] = value
+    return env
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--platform-root",
+        type=Path,
+        required=True,
+        help="Path to the gigaevo-platform repo in the workspace.",
+    )
+    parser.add_argument(
+        "--mode",
+        choices=("dev", "prod"),
+        default="dev",
+        help="Build target (dev/prod), matches upstream build_runner_image.sh.",
+    )
+    args = parser.parse_args(argv)
+
+    platform_root = args.platform_root.resolve()
+    src = platform_root / "runner_api" / "Dockerfile"
+    if not src.is_file():
+        print(f"build_runner_slim: missing {src}", file=sys.stderr)
+        return 2
+
+    slim_path = src.parent / "Dockerfile.slim"
+    slim_path.write_text(_patch_dockerfile(src), encoding="utf-8")
+    print(f"[build-runner-slim] wrote {slim_path}")
+
+    env = _source_env_file(platform_root / ".env")
+    image_name = env.get("RUNNER_IMAGE_NAME") or os.environ.get("RUNNER_IMAGE_NAME")
+    if not image_name:
+        # Mirror upstream's fallback so wizard-driven flows still work
+        # before the .env has been seeded with COMPOSE_PROJECT_NAME.
+        project = env.get("COMPOSE_PROJECT_NAME") or "gigaevo-platform"
+        image_name = f"{project}-runner-api"
+
+    docker_args = [
+        "docker", "build",
+        "--file", str(slim_path),
+        "--target", args.mode,
+        "--tag", image_name,
+        "--build-arg", f"GIGAEVO_CORE_REF={env.get('GIGAEVO_CORE_REF', 'main')}",
+        "--build-arg",
+        "GIGAEVO_CORE_REPO_URL=" + env.get(
+            "GIGAEVO_CORE_REPO_URL",
+            "https://github.com/FusionBrainLab/gigaevo-core",
+        ),
+        str(platform_root),
+    ]
+    if os.environ.get("GITHUB_PAT"):
+        docker_args[2:2] = ["--secret", "id=github_pat,env=GITHUB_PAT"]
+
+    print(f"[build-runner-slim] building {image_name} (mode={args.mode})")
+    env_for_build = {**os.environ, "DOCKER_BUILDKIT": "1"}
+    result = subprocess.run(docker_args, env=env_for_build, check=False)
+    return result.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

care_install/i18n.py

@@ -0,0 +1,94 @@
+"""Key-based UI localization for the maestro-install wizard (Russian default).
+
+Mirrors the approach used in the CARE TUI (``care/runtime/i18n.py``): strings
+live in per-language JSON catalogs under ``locales/`` and are looked up by a
+dotted key — the same shape as JS i18n libraries::
+
+    from i18n import t
+    print(t("banner.title"))
+    print(t("action.detected", path=workspace))
+
+The catalog is nested JSON; keys address it with dots
+(``"service.howProvisioned"``). Values may carry ``str.format`` placeholders
+filled from keyword args. Lookup order: active language → English fallback →
+the key itself (so a missing translation is visible, not a crash).
+
+Works both as a standalone script import (``import i18n`` — the wizard runs via
+``uv run --script`` with its own directory on ``sys.path``) and as part of the
+installed package (``from . import i18n`` → ``care_install.i18n``). Catalogs
+are read by file path relative to *this* module, so no package-resource magic
+is needed in either layout.
+"""
+
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+_LOCALES_DIR = Path(__file__).resolve().parent / "locales"
+
+#: Languages we ship. The first is the default; the last is the fallback the
+#: lookup walks to when a key is missing in the active catalog.
+SUPPORTED: tuple[str, ...] = ("ru", "en")
+_FALLBACK_LANGUAGE = "en"
+
+# Process-global active language. Defaults to Russian; set once near wizard
+# start via :func:`set_language`. Read on every :func:`t` call.
+_language = "ru"
+
+
+def set_language(language: str | None) -> None:
+    """Set the active language. Unknown / ``None`` falls back to Russian."""
+    global _language
+    lang = str(language or "").strip().lower()
+    _language = lang if lang in SUPPORTED else "ru"
+
+
+def get_language() -> str:
+    """Return the active language code (``"ru"`` or ``"en"``)."""
+    return _language
+
+
+def _flatten(node: dict[str, Any], prefix: str = "") -> dict[str, str]:
+    """Flatten a nested catalog into ``{"a.b.c": "text"}`` pairs."""
+    flat: dict[str, str] = {}
+    for key, value in node.items():
+        dotted = f"{prefix}.{key}" if prefix else key
+        if isinstance(value, dict):
+            flat.update(_flatten(value, dotted))
+        else:
+            flat[dotted] = value
+    return flat
+
+
+@lru_cache(maxsize=None)
+def _catalog(language: str) -> dict[str, str]:
+    """Load + flatten a language catalog (cached for the process lifetime)."""
+    path = _LOCALES_DIR / f"{language}.json"
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError:
+        return {}
+    return _flatten(json.loads(raw))
+
+
+def t(key: str, /, **params: Any) -> str:
+    """Translate *key* into the active language.
+
+    Falls back to the English catalog when the active language lacks the key,
+    then to the raw key so a typo is visible rather than silent. ``params``
+    fill ``str.format`` placeholders; a missing arg leaves the template intact.
+    """
+    text = _catalog(_language).get(key)
+    if text is None and _language != _FALLBACK_LANGUAGE:
+        text = _catalog(_FALLBACK_LANGUAGE).get(key)
+    if text is None:
+        text = key
+    if params:
+        try:
+            return text.format(**params)
+        except (KeyError, IndexError, ValueError):
+            return text
+    return text