refactorai-cli 0.4.0__tar.gz → 0.4.2__tar.gz

{refactorai_cli-0.4.0 → refactorai_cli-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.4.0
+Version: 0.4.2
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -8,7 +8,7 @@ Requires-Dist: typer>=0.12.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: PyYAML>=6.0.1
-Requires-Dist: refactorai-core>=3.2.0
+Requires-Dist: refactorai-core>=3.2.1
 
 # refactorai-cli
 

{refactorai_cli-0.4.0 → refactorai_cli-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "refactorai-cli"
-version = "0.4.0"
+version = "0.4.2"
 description = "Local-first CLI for the refactor platform"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -12,7 +12,7 @@ dependencies = [
   "httpx>=0.27.0",
   "rich>=13.7.0",
   "PyYAML>=6.0.1",
-  "refactorai-core>=3.2.0",
+  "refactorai-core>=3.2.1",
 ]
 
 [project.scripts]

{refactorai_cli-0.4.0 → refactorai_cli-0.4.2}/refactorai_cli/__init__.py

@@ -5,4 +5,4 @@ the shared `refactor_core` pipeline from a project folder while staying
 authenticated to the hosted platform via a developer key.
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

{refactorai_cli-0.4.0 → refactorai_cli-0.4.2}/refactorai_cli/commands/hook_cmds.py

@@ -55,22 +55,15 @@ def _require_repo(project_root: Path) -> str:
     return root
 
 
-@app.command("install")
-def install(
-    hooks_dir: str | None = typer.Option(
-        None,
-        "--hooks-dir",
-        help=f"Directory to hold git hooks (default: existing core.hooksPath or {_DEFAULT_HOOKS_DIR}).",
-    ),
-    force: bool = typer.Option(
-        False,
-        "--force",
-        help="Overwrite an existing non-RefactorAI post-commit hook.",
-    ),
-) -> None:
-    """Install the non-blocking post-commit hook and wire ``core.hooksPath``."""
-    root = Path(_require_repo(Path.cwd()))
-
+def perform_install(
+    root: Path, *, hooks_dir: str | None = None, force: bool = False
+) -> dict:
+    """Install the post-commit hook + wire ``core.hooksPath`` (no printing/exit).
+
+    Returns a result dict with ``status`` in ``{installed, exists_foreign, error}``
+    plus ``rel_dir``, ``hook_file`` and a human ``message``. Shared by the
+    ``hook install`` command and ``refactor init`` so both stay in lockstep.
+    """
     existing_path = git_scope.get_config(root, "core.hooksPath")
     if hooks_dir:
         rel_dir = hooks_dir
@@ -83,29 +76,68 @@ def install(
     hook_file = hooks_path / "post-commit"
 
     if hook_file.exists() and _HOOK_MARKER not in _safe_read(hook_file) and not force:
-        console.print(
-            f"[yellow]hook:[/yellow] a post-commit hook already exists at {hook_file}.\n"
-            "Re-run with [bold]--force[/bold] to overwrite, or point --hooks-dir elsewhere."
-        )
-        raise typer.Exit(code=1)
+        return {
+            "status": "exists_foreign",
+            "rel_dir": rel_dir,
+            "hook_file": hook_file,
+            "message": f"a post-commit hook already exists at {hook_file}",
+        }
 
     try:
         hooks_path.mkdir(parents=True, exist_ok=True)
         hook_file.write_text(_POST_COMMIT_SCRIPT, encoding="utf-8")
         hook_file.chmod(hook_file.stat().st_mode | 0o755)
     except OSError as exc:
-        console.print(f"[red]hook: could not write hook:[/red] {exc}")
-        raise typer.Exit(code=1) from exc
+        return {"status": "error", "rel_dir": rel_dir, "hook_file": None, "message": str(exc)}
 
     if not git_scope.set_config(root, "core.hooksPath", rel_dir):
-        console.print("[red]hook: could not set core.hooksPath.[/red]")
+        return {
+            "status": "error",
+            "rel_dir": rel_dir,
+            "hook_file": hook_file,
+            "message": "could not set core.hooksPath",
+        }
+
+    return {
+        "status": "installed",
+        "rel_dir": rel_dir,
+        "hook_file": hook_file,
+        "message": f"installed post-commit hook -> {hook_file}",
+    }
+
+
+@app.command("install")
+def install(
+    hooks_dir: str | None = typer.Option(
+        None,
+        "--hooks-dir",
+        help=f"Directory to hold git hooks (default: existing core.hooksPath or {_DEFAULT_HOOKS_DIR}).",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="Overwrite an existing non-RefactorAI post-commit hook.",
+    ),
+) -> None:
+    """Install the non-blocking post-commit hook and wire ``core.hooksPath``."""
+    root = Path(_require_repo(Path.cwd()))
+    result = perform_install(root, hooks_dir=hooks_dir, force=force)
+
+    if result["status"] == "exists_foreign":
+        console.print(
+            f"[yellow]hook:[/yellow] {result['message']}.\n"
+            "Re-run with [bold]--force[/bold] to overwrite, or point --hooks-dir elsewhere."
+        )
+        raise typer.Exit(code=1)
+    if result["status"] == "error":
+        console.print(f"[red]hook: could not install:[/red] {result['message']}")
         raise typer.Exit(code=1)
 
     console.print(
-        f"[green]Installed[/green] post-commit hook -> {hook_file}\n"
-        f"[dim]core.hooksPath = {rel_dir}[/dim]\n"
+        f"[green]Installed[/green] post-commit hook -> {result['hook_file']}\n"
+        f"[dim]core.hooksPath = {result['rel_dir']}[/dim]\n"
         "Every commit now enqueues a local review event. "
-        "Open the Refactor Terminal with `refactor watch` (coming in Phase 3)."
+        "Open the Refactor Terminal with `refactor watch`."
     )
 
 

{refactorai_cli-0.4.0 → refactorai_cli-0.4.2}/refactorai_cli/commands/run_cmds.py

@@ -72,7 +72,7 @@ from refactor_core.refactor_requests import (
     save_request,
 )
 from refactor_core.refactor_ops import remediation_hint
-from refactor_core.indexing import index_target
+from refactor_core.indexing import index_paths, index_target
 from refactor_core.models import Finding, GeneratedTest, PatchGroup, RunArtifact
 from refactor_core.rules import annotate_documents_with_rules, filter_documents_by_rules
 from refactor_core.security import (
@@ -101,6 +101,7 @@ from refactor_core.store import (
 from refactor_core.testcmd import resolve_test_command
 
 from refactorai_cli.auth import AuthError, ensure_authenticated
+from refactorai_cli.dotenv_loader import DotenvResult, load_project_dotenv
 from refactorai_cli.local_engine_runtime import DEFAULT_ENGINE_PORT, read_engine_state
 from refactorai_cli.runtime_manager import runtime_status, runtime_version_dir
 from refactorai_cli.settings import platform_url
@@ -679,12 +680,19 @@ def _cloud_inference(
     target: str,
     model_hint: str | None = None,
     findings: list | None = None,
+    scope_paths: list[str] | None = None,
 ) -> RunArtifact:
     _raw_alerts = constitution.get_setting("max_alerts_per_run", 5)
     max_alerts = int(_raw_alerts if _raw_alerts is not None else 5)
     gate_mode = str(constitution.get_setting("gate_mode", "strict") or "strict")
     excludes = set(constitution.get_setting("exclude", []) or [])
-    documents = index_target(Path(project_root), target, excludes=excludes)
+    # Commit-scoped cloud review (docs/41 `R28`): when a scope is supplied, index
+    # only the changed + graph-associated files instead of the whole target, so a
+    # BYOK/managed commit review sends just the relevant documents to the platform.
+    if scope_paths is not None:
+        documents = index_paths(Path(project_root), scope_paths, excludes=excludes)
+    else:
+        documents = index_target(Path(project_root), target, excludes=excludes)
     documents, _scope_meta = filter_documents_by_rules(documents, project_root=Path(project_root))
     rule_meta = annotate_documents_with_rules(documents, project_root=Path(project_root))
 
@@ -1029,6 +1037,59 @@ def init(
         "all run state stays under ~/.refactor "
         f"(encoded: {record['encoded']})."
     )
+    _offer_commit_hook(project_root)
+
+
+def _offer_commit_hook(project_root: Path) -> None:
+    """Offer to wire the local commit-review hook during `init` (docs/41 `R28`).
+
+    Interactive TTYs get a yes/no prompt (default yes); non-interactive runs
+    (CI/agents) print a one-line tip instead of blocking. Never fails `init`.
+    """
+    try:
+        from refactorai_cli import git_scope
+        from refactorai_cli.commands import hook_cmds
+    except Exception:
+        return
+
+    if not git_scope.is_git_repo(project_root):
+        console.print(
+            "[dim]Tip:[/dim] this folder is not a git repo yet. After `git init`, run "
+            "[bold]refactor hook install[/bold] to review each commit before push."
+        )
+        return
+
+    if not sys.stdin.isatty():
+        console.print(
+            "[dim]Tip:[/dim] run [bold]refactor hook install[/bold] to enable "
+            "commit-triggered local review (docs/41)."
+        )
+        return
+
+    if not typer.confirm(
+        "Install the post-commit review hook for this repo now?", default=True
+    ):
+        console.print(
+            "[dim]Skipped. Run [bold]refactor hook install[/bold] anytime to enable it.[/dim]"
+        )
+        return
+
+    result = hook_cmds.perform_install(project_root)
+    status = result.get("status")
+    if status == "installed":
+        console.print(
+            f"[green]Installed[/green] post-commit review hook "
+            f"[dim](core.hooksPath = {result['rel_dir']})[/dim]. "
+            "Open the Refactor Terminal with [bold]refactor watch[/bold]."
+        )
+    elif status == "exists_foreign":
+        console.print(
+            f"[yellow]A different post-commit hook already exists[/yellow] "
+            f"({result['hook_file']}). Run [bold]refactor hook install --force[/bold] "
+            "to replace it, or point [bold]--hooks-dir[/bold] elsewhere."
+        )
+    else:
+        console.print(f"[yellow]Could not install hook:[/yellow] {result.get('message')}")
 
 
 _ENV_ASSIGN_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*=.*$")
@@ -1949,14 +2010,14 @@ def review(
         None,
         "--commit",
         help="Scope the review to a commit's changed files + graph-associated "
-        "files (local only, docs/41). Use a SHA/ref; the repo root commit falls "
-        "back to a full-project review.",
+        "files (docs/41; works in local and cloud/BYOK modes). Use a SHA/ref; the "
+        "repo root commit falls back to a full-project review.",
     ),
     changed: bool = typer.Option(
         False,
         "--changed",
         help="Scope the review to the working tree's changed files + "
-        "graph-associated files (local only).",
+        "graph-associated files.",
     ),
     intent: str | None = typer.Option(
         None,
@@ -2026,14 +2087,10 @@ def review(
     register_project(project_root, constitution_hash=constitution.content_hash)
     _maybe_build_graph(project_root, project_config)
 
-    # Commit-scoped local review (docs/41 `R28`). Local-only: the cloud path does
-    # not carry an explicit file scope, so scoping + cloud mode is rejected early.
-    if (commit or changed) and _is_cloud_mode(constitution):
-        console.print(
-            "[red]review: --commit/--changed is local-only[/red] and is not "
-            f"supported in {_cloud_execution_mode(constitution)} mode."
-        )
-        raise typer.Exit(code=2)
+    # Commit-scoped review (docs/41 `R28`). Works in every execution mode: local
+    # runs it through the runtime, while cloud/BYOK index only the changed +
+    # associated files and send just those documents to the platform (so the
+    # commit loop runs without a downloaded runtime artifact).
     scope = _resolve_commit_scope(
         project_root=project_root,
         constitution=constitution,
@@ -2074,7 +2131,10 @@ def review(
                 constitution=constitution,
                 target=target,
                 model_hint=provider,
+                scope_paths=scope_paths,
             )
+            if scope and scope.get("summary"):
+                artifact.notes.append(f"Commit-scoped review intent: {scope['summary']}")
         else:
             from refactor_core.execution.orchestrator import run_with_mode
             from refactor_core.providers import get_provider
@@ -2204,13 +2264,13 @@ def code(
         None,
         "--commit",
         help="Scope to a commit's changed + graph-associated files and (re)create "
-        "that commit's refactor requests before resolving them (local only, docs/41). "
-        "Used by the Refactor Terminal's [r] action.",
+        "that commit's refactor requests before resolving them (docs/41; works in "
+        "local and cloud/BYOK modes). Used by the Refactor Terminal's [r] action.",
     ),
     changed: bool = typer.Option(
         False,
         "--changed",
-        help="Scope to the working tree's changed + graph-associated files (local only).",
+        help="Scope to the working tree's changed + graph-associated files.",
     ),
     intent: str | None = typer.Option(
         None,
@@ -2299,16 +2359,11 @@ def code(
     register_project(project_root, constitution_hash=constitution.content_hash)
     _maybe_build_graph(project_root, project_config)
 
-    # Commit-scoped resolve (docs/41 `R28`, Phase 4). Local-only, symmetric to
-    # `review`. When scoped, we (re)create THIS commit's requests via a scoped
-    # review-first so `[r]` in the Refactor Terminal resolves the selected
-    # commit's requests rather than a stale pending set.
-    if (commit or changed) and _is_cloud_mode(constitution):
-        console.print(
-            "[red]code: --commit/--changed is local-only[/red] and is not "
-            f"supported in {_cloud_execution_mode(constitution)} mode."
-        )
-        raise typer.Exit(code=2)
+    # Commit-scoped resolve (docs/41 `R28`, Phase 4), symmetric to `review` and
+    # available in every execution mode. When scoped, we (re)create THIS commit's
+    # requests via a scoped review-first so `[r]` in the Refactor Terminal resolves
+    # the selected commit's requests rather than a stale pending set. In cloud/BYOK
+    # the review-first sends only the scoped documents to the platform.
     code_scope = _resolve_commit_scope(
         project_root=project_root,
         constitution=constitution,
@@ -2372,6 +2427,7 @@ def code(
                     constitution=constitution,
                     target=target,
                     model_hint=provider,
+                    scope_paths=code_scope_paths,
                 )
                 cloud_review_findings = list(review_artifact.findings or [])
             else:
@@ -3570,6 +3626,25 @@ def _print_detected_credentials(provider_name: str) -> None:
                 break
 
 
+def _report_dotenv(result: DotenvResult, project_root: Path) -> None:
+    """Print a concise ``.env`` status line for `doctor` diagnostics.
+
+    The entrypoint loads ``.env`` before any command runs, so ``result.present``
+    (not ``applied``) reflects what the file contributes. Values are never shown.
+    """
+    if result.found:
+        count = len(result.present)
+        console.print(
+            f"[green].env[/green]: loaded {count} var{'s' if count != 1 else ''} "
+            f"from {result.path}"
+        )
+    else:
+        console.print(
+            f"[yellow].env[/yellow]: none found near {project_root} "
+            "(export your provider vars, or create a .env next to refactor.config)."
+        )
+
+
 def _missing_requirements(provider_name: str) -> list[str]:
     requirements = _REQUIRED_ENV_BY_PROVIDER.get(provider_name, [])
     missing: list[str] = []
@@ -3589,6 +3664,7 @@ def _cloud_doctor(
     constitution,
     execution_mode: str,
     skip_ping: bool,
+    dotenv: DotenvResult | None = None,
 ) -> None:
     """Cloud-mode readiness checks (C7): auth, entitlement, endpoint, credential.
 
@@ -3637,6 +3713,11 @@ def _cloud_doctor(
                 "[red]cloud_byok[/red]: set either `provider_key` (preferred) "
                 "or `credential_ref` in refactor.config."
             )
+            if dotenv is not None and not dotenv.found:
+                console.print(
+                    "[dim]  Tip: if `provider_key` uses ${ENV_VAR}, put that var in a "
+                    ".env next to refactor.config (refactor loads it automatically).[/dim]"
+                )
             raise typer.Exit(code=1)
 
     if skip_ping:
@@ -3758,14 +3839,23 @@ def doctor(
         )
         raise typer.Exit(code=1)
     consti_path, _ = files
+    project_root = consti_path.parent
+
+    # Load ``.env`` BEFORE parsing config so ``${VAR}`` interpolation (for
+    # example ``provider_key: ${OPENAI_API_KEY}``) resolves from it. The
+    # entrypoint already loads it for real runs; here we also surface the status
+    # so a missing/misconfigured ``.env`` is flagged during diagnostics.
+    dotenv = load_project_dotenv(project_root)
+
     constitution = load_constitution(consti_path)
     project_config = load_config(consti_path.parent / CONFIG_FILENAME)
-    project_root = consti_path.parent
 
     if sandbox:
         _report_sandbox(project_root, project_config)
         return
 
+    _report_dotenv(dotenv, project_root)
+
     execution_mode = _cloud_execution_mode(constitution)
     if execution_mode:
         _cloud_doctor(
@@ -3773,6 +3863,7 @@ def doctor(
             constitution=constitution,
             execution_mode=execution_mode,
             skip_ping=skip_ping,
+            dotenv=dotenv,
         )
         return
 
@@ -3807,6 +3898,16 @@ def doctor(
         console.print("[red]provider env[/red]: missing required values:")
         for item in missing:
             console.print(f"  - {item}")
+        if not dotenv.found:
+            console.print(
+                "[dim]  Tip: create a .env next to refactor.config with these vars "
+                "(refactor loads it automatically), or export them in your shell.[/dim]"
+            )
+        else:
+            console.print(
+                f"[dim]  Tip: add these vars to {dotenv.path} "
+                "(refactor loads it automatically).[/dim]"
+            )
         raise typer.Exit(code=1)
     console.print("[green]provider env[/green]: OK")
     _print_detected_credentials(provider_name)

refactorai_cli-0.4.2/refactorai_cli/dotenv_loader.py

@@ -0,0 +1,112 @@
+"""Minimal, dependency-free ``.env`` loading for the CLI.
+
+Developers configure BYOK/provider credentials in ``refactor.config`` using
+``${VAR}`` interpolation (for example ``provider_key: ${OPENAI_API_KEY}``).
+Those tokens are resolved from ``os.environ`` at config-parse time, which means
+a developer would otherwise have to ``set -a; source .env; set +a`` in every
+shell (and the git hook's shell) before ``refactor`` could see the values.
+
+This module loads a project ``.env`` into ``os.environ`` so that interpolation
+"just works". It is intentionally tiny and has no third-party dependency so the
+thin client stays light and deterministic.
+
+Precedence: the real process environment always wins. Existing variables are
+never overwritten unless ``override=True`` is passed explicitly.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+DOTENV_FILENAME = ".env"
+DISABLE_ENV = "REFACTOR_NO_DOTENV"
+_KEY_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+_TRUTHY = {"1", "true", "yes", "on"}
+
+
+@dataclass
+class DotenvResult:
+    """Outcome of a ``.env`` load attempt (used for diagnostics/reporting)."""
+
+    path: Path | None = None
+    present: list[str] = field(default_factory=list)
+    applied: list[str] = field(default_factory=list)
+
+    @property
+    def found(self) -> bool:
+        return self.path is not None
+
+
+def _disabled() -> bool:
+    return os.environ.get(DISABLE_ENV, "").strip().lower() in _TRUTHY
+
+
+def find_dotenv(start: Path | None = None) -> Path | None:
+    """Return the nearest ``.env`` searching ``start`` (or CWD) and its parents."""
+    try:
+        current = Path(start).resolve() if start is not None else Path.cwd().resolve()
+    except OSError:
+        return None
+    for candidate in [current, *current.parents]:
+        env_path = candidate / DOTENV_FILENAME
+        if env_path.is_file():
+            return env_path
+    return None
+
+
+def _strip_quotes(value: str) -> str:
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in ("'", '"'):
+        return value[1:-1]
+    return value
+
+
+def parse_dotenv(text: str) -> dict[str, str]:
+    """Parse ``KEY=VALUE`` lines. Supports ``export`` prefix and quoted values.
+
+    Comment lines (``#``) and blanks are ignored. Inline comments are *not*
+    stripped so secret values containing ``#`` are preserved verbatim.
+    """
+    parsed: dict[str, str] = {}
+    for raw_line in text.replace("\r\n", "\n").split("\n"):
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if line.startswith("export "):
+            line = line[len("export "):].lstrip()
+        if "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key = key.strip()
+        if not _KEY_RE.match(key):
+            continue
+        parsed[key] = _strip_quotes(value.strip())
+    return parsed
+
+
+def load_project_dotenv(start: Path | None = None, *, override: bool = False) -> DotenvResult:
+    """Load the nearest ``.env`` into ``os.environ`` (real env wins by default).
+
+    Returns a :class:`DotenvResult` describing what was found and applied so
+    callers such as ``refactor doctor`` can report it. Never raises: any I/O or
+    parse issue degrades to an empty/partial result.
+    """
+    if _disabled():
+        return DotenvResult()
+    env_path = find_dotenv(start)
+    if env_path is None:
+        return DotenvResult()
+    try:
+        text = env_path.read_text(encoding="utf-8")
+    except OSError:
+        return DotenvResult(path=env_path)
+    parsed = parse_dotenv(text)
+    applied: list[str] = []
+    for key, value in parsed.items():
+        if not override and key in os.environ:
+            continue
+        os.environ[key] = value
+        applied.append(key)
+    return DotenvResult(path=env_path, present=list(parsed.keys()), applied=applied)

{refactorai_cli-0.4.0 → refactorai_cli-0.4.2}/refactorai_cli/main.py

@@ -96,6 +96,17 @@ def main(
     ),
 ) -> None:
     """refactor CLI."""
+    # Load a project ``.env`` early so ``${VAR}`` interpolation in
+    # ``refactor.config`` (and provider SDKs) resolves for every command and for
+    # the git-hook-driven commit loop, without a manual ``source .env``. Real
+    # environment variables always win; failures never break dispatch.
+    try:
+        from refactorai_cli.dotenv_loader import load_project_dotenv
+
+        load_project_dotenv()
+    except Exception:
+        pass
+
     command_name = (ctx.invoked_subcommand or "").strip().lower()
     if command_name in _INTRO_COMMANDS:
         _print_agent_intro(command_name)

{refactorai_cli-0.4.0 → refactorai_cli-0.4.2}/refactorai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: refactorai-cli
-Version: 0.4.0
+Version: 0.4.2
 Summary: Local-first CLI for the refactor platform
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -8,7 +8,7 @@ Requires-Dist: typer>=0.12.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.7.0
 Requires-Dist: PyYAML>=6.0.1
-Requires-Dist: refactorai-core>=3.2.0
+Requires-Dist: refactorai-core>=3.2.1
 
 # refactorai-cli
 

{refactorai_cli-0.4.0 → refactorai_cli-0.4.2}/refactorai_cli.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ refactorai_cli/cloud_rr.py
 refactorai_cli/commit_queue.py
 refactorai_cli/control_plane.py
 refactorai_cli/credentials.py
+refactorai_cli/dotenv_loader.py
 refactorai_cli/git_scope.py
 refactorai_cli/local_constitution.py
 refactorai_cli/local_engine_runtime.py

{refactorai_cli-0.4.0 → refactorai_cli-0.4.2}/refactorai_cli.egg-info/requires.txt

@@ -2,4 +2,4 @@ typer>=0.12.0
 httpx>=0.27.0
 rich>=13.7.0
 PyYAML>=6.0.1
-refactorai-core>=3.2.0
+refactorai-core>=3.2.1