remoroo 0.1.0__tar.gz

remoroo-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.1
+Name: remoroo
+Version: 0.1.0
+Summary: Remoroo Offline Engine CLI
+Requires-Python: >=3.9
+Requires-Dist: typer>=0.9.0
+Requires-Dist: jsonschema>=4.22.0
+Requires-Dist: openai>=1.40.0
+Requires-Dist: requests>=2.31.0

remoroo-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools<70.0.0", "wheel", "packaging>=23.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "remoroo"
+version = "0.1.0"
+description = "Remoroo Offline Engine CLI"
+requires-python = ">=3.9"
+dependencies = [
+    "typer>=0.9.0",
+    "jsonschema>=4.22.0",
+    "openai>=1.40.0",
+    "requests>=2.31.0",
+]
+
+[project.scripts]
+remoroo = "remoroo.cli:app"
+
+[tool.setuptools.packages.find]
+include = ["remoroo*", "remoroo_offline*"]

remoroo-0.1.0/remoroo/__init__.py

@@ -0,0 +1 @@
+

remoroo-0.1.0/remoroo/auth.py

@@ -0,0 +1,111 @@
+import os
+import json
+from pathlib import Path
+from typing import Optional, Dict, Any
+import typer
+import webbrowser
+import time
+
+CRED_PATH = Path.home() / ".config" / "remoroo" / "credentials"
+
+class AuthClient:
+    def __init__(self, base_url: Optional[str] = None):
+        self.base_url = base_url or os.environ.get("REMOROO_API_URL", "https://api.remoroo.com")
+        self.auth_url = os.environ.get("REMOROO_AUTH_URL", "http://localhost:3000/console") # Point to console for key generation
+        self._token: Optional[str] = None
+        self._load_token()
+
+    def _load_token(self):
+        if CRED_PATH.exists():
+            try:
+                content = CRED_PATH.read_text().strip()
+                # Simple format: just the token for now, or JSON later
+                self._token = content
+            except Exception:
+                pass
+
+    def is_authenticated(self) -> bool:
+        return bool(self._token)
+        
+    def get_token(self) -> Optional[str]:
+        return self._token
+
+    def login(self) -> None:
+        """Interactive login flow."""
+        if self.is_authenticated():
+            typer.echo("Already logged in.")
+            return
+
+        CRED_PATH.parent.mkdir(parents=True, exist_ok=True)
+        
+        typer.secho("Opening browser to sign in...", fg=typer.colors.BLUE)
+        print(f"URL: {self.auth_url}")
+        
+        try:
+            webbrowser.open(self.auth_url)
+        except Exception:
+            typer.echo("Could not open browser automatically.")
+            
+        token = typer.prompt("Paste your API key (will be saved locally)", hide_input=True)
+        token = (token or "").strip()
+        
+        if not token:
+            typer.secho("Login aborted.", fg=typer.colors.RED)
+            raise typer.Exit(code=1)
+            
+        # Validate Token
+        try:
+            import requests # Make sure requests is imported or available
+            typer.echo("Verifying credentials...")
+            res = requests.get(f"{self.base_url}/user/me", headers={"Authorization": token})
+            if res.status_code == 200:
+                user = res.json()
+                typer.secho(f"Successfully logged in as {user.get('email') or user.get('username')}", fg=typer.colors.GREEN)
+                self._save_token(token)
+            else:
+                 typer.secho(f"Login failed: {res.status_code} - Invalid API Key", fg=typer.colors.RED)
+                 raise typer.Exit(code=1)
+        except Exception as e:
+             typer.secho(f"Verification error: {e}", fg=typer.colors.YELLOW)
+             # Proceed? No, fail secure.
+             raise typer.Exit(code=1)
+
+    def logout(self) -> None:
+        if CRED_PATH.exists():
+            CRED_PATH.unlink()
+        self._token = None
+        typer.echo("Logged out.")
+
+    def _save_token(self, token: str) -> None:
+        self._token = token
+        tmp = CRED_PATH.with_suffix(".tmp")
+        tmp.write_text(token + "\n", encoding="utf-8")
+        tmp.replace(CRED_PATH)
+        try:
+            os.chmod(CRED_PATH, 0o600)
+        except Exception:
+            pass
+
+    def create_run(self, repo_path: str, goal: str, mode: str) -> Dict[str, Any]:
+        """
+        Mock create run - in future this hits the Control Plane API.
+        Returns a run configuration/ID.
+        """
+        # Mock response
+        run_id = time.strftime("%Y%m%d-%H%M%S") + "-" + os.urandom(4).hex()
+        return {
+            "run_id": run_id,
+            "status": "created",
+            "config": {
+                "goal": goal,
+                "mode": mode
+            }
+        }
+
+# Global instance for CLI convenience, but preferable to instantiate in commands
+_client = AuthClient()
+
+def ensure_logged_in() -> AuthClient:
+    if not _client.is_authenticated():
+        _client.login()
+    return _client

remoroo-0.1.0/remoroo/cli.py

@@ -0,0 +1,134 @@
+import typer
+from pathlib import Path
+
+from .auth import ensure_logged_in
+from .prompts import prompt_goal, prompt_metrics, confirm_run
+from .ids import new_run_id
+from .paths import resolve_repo_path, resolve_out_dir
+
+
+from .run_local import run_local_worker
+
+from .worker_cmd import worker
+app = typer.Typer(no_args_is_help=True)
+app.command(name="worker")(worker)
+
+@app.command()
+def login():
+    """Lock in your API Key."""
+    from .auth import _client
+    _client.login()
+
+@app.command()
+def logout():
+    """Remove stored credentials."""
+    from .auth import _client
+    _client.logout()
+
+@app.callback()
+def main():
+    """
+    Remoroo CLI
+    """
+    pass
+
+@app.command()
+def run(
+    local: bool = typer.Option(False, "--local", help="Run execution on this machine (Free/Offline)."),
+    remote: bool = typer.Option(True, "--remote", help="Run execution on hosted Cloud Engine (Commercial)."),
+    repo: Path = typer.Option(Path("."), "--repo", exists=True, file_okay=False, dir_okay=True),
+    out: Path = typer.Option(None, "--out", help="Base directory for run outputs."),
+    yes: bool = typer.Option(False, "--yes", help="Skip confirmation."),
+    verbose: bool = typer.Option(False, "--verbose", help="Verbose output."),
+    goal: str = typer.Option(None, "--goal", help="Goal of the run."),
+    metrics: str = typer.Option(None, "--metrics", help="Comma-separated metrics."),
+    brain_url: str = typer.Option(None, "--brain-url", help="URL of the Brain Server."),
+):
+    from .configs import get_api_url
+    if brain_url is None:
+        brain_url = get_api_url()
+    # Logic: Default is Remote. 
+    # If user explicitly says --local, then remote=False. 
+    # Because 'remote' defaults to True, we check if local is True.
+    if local:
+        remote = False
+
+    if remote:
+        from .run_remote import run_remote_experiment
+        # typer.secho("Remote execution is not available yet.", fg=typer.colors.YELLOW)
+        # raise typer.Exit(code=2)
+        # Prepare arguments
+        if not goal:
+            goal = prompt_goal()
+        
+        metrics_list = []
+        if metrics:
+            metrics_list = [m.strip() for m in metrics.split(",") if m.strip()]
+        if not metrics_list:
+            metrics_list = prompt_metrics()
+
+        try:
+             res = run_remote_experiment(
+                run_id=new_run_id(),
+                repo_path=resolve_repo_path(repo),
+                out_dir=resolve_out_dir(out, resolve_repo_path(repo)),
+                goal=goal,
+                metrics=metrics_list,
+             )
+             typer.echo(f"Run outcome: {res.outcome}")
+             raise typer.Exit(code=0)
+        except Exception as e:
+             typer.echo(f"Error: {e}")
+             raise typer.Exit(code=1)
+
+    ensure_logged_in()
+
+    repo_path = resolve_repo_path(repo)
+    out_dir = resolve_out_dir(out, repo_path)
+
+    if not goal:
+        goal = prompt_goal()
+    
+    metrics_list = []
+    if metrics:
+        metrics_list = [m.strip() for m in metrics.split(",") if m.strip()]
+    
+    if not metrics_list:
+        metrics_list = prompt_metrics()
+
+    run_id = new_run_id()
+
+    if not yes:
+        if not confirm_run(repo_path, goal, metrics_list, mode="local"):
+            raise typer.Exit(code=0)
+
+    typer.secho(f"\nStarting run {run_id}...", fg=typer.colors.BLUE)
+    
+    try:
+        result = run_local_worker(
+            run_id=run_id,
+            repo_path=repo_path,
+            out_dir=out_dir,
+            goal=goal,
+            metrics=metrics_list,
+            brain_url=brain_url,
+            verbose=verbose,
+        )
+
+        if result.success:
+            typer.secho("Run completed successfully.", fg=typer.colors.GREEN)
+        else:
+            typer.secho(f"Run finished with outcome: {result.outcome}", fg=typer.colors.YELLOW)
+            
+        typer.echo(f"Run ID: {result.run_id}")
+        typer.echo(f"Results saved to: {result.run_root}")
+        
+    except Exception as e:
+        typer.secho(f"Run failed with error: {e}", fg=typer.colors.RED)
+        if verbose:
+            import traceback
+            traceback.print_exc()
+        raise typer.Exit(code=1)
+
+if __name__ == "__main__":
+    app()

remoroo-0.1.0/remoroo/configs.py

@@ -0,0 +1,7 @@
+import os
+
+def get_api_url() -> str:
+    """
+    Get the Remoroo API URL from environment variables or use default.
+    """
+    return os.getenv("REMOROO_API_URL", "http://localhost:8000").rstrip("/")

remoroo-0.1.0/remoroo/engine/__init__.py

@@ -0,0 +1,2 @@
+# Remoroo CLI Local Execution Engine
+# Embeds minimal execution logic for local runs.

remoroo-0.1.0/remoroo/engine/core/applier.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+import os
+import codecs
+from pathlib import Path
+from typing import Dict, Any, List, Tuple, Optional, TYPE_CHECKING
+from ..utils.syntax_validator import validate_python_syntax, preserve_indentation, get_indentation_level, auto_fix_indentation
+
+if TYPE_CHECKING:
+    from ..utils.file_access_tracker import FileAccessTracker
+
+class ApplyError(RuntimeError):
+    pass
+
+def _read_text(path: str) -> str:
+    with open(path, "r", encoding="utf-8", errors="replace") as f:
+        return f.read()
+
+def _read_lines(path: str) -> List[str]:
+    with open(path, "r", encoding="utf-8", errors="replace") as f:
+        return f.readlines()
+
+def _write_text(path: str, text: str) -> None:
+    try:
+        dir_path = os.path.dirname(path)
+        if dir_path:
+            os.makedirs(dir_path, exist_ok=True)
+        with open(path, "w", encoding="utf-8", newline="\n") as f:
+            f.write(text)
+    except (OSError, PermissionError) as e:
+        raise ApplyError(f"Failed to create directory or write file '{path}': {str(e)}") from e
+    except Exception as e:
+        raise ApplyError(f"Failed to write file '{path}': {str(e)}") from e
+
+def _write_lines(path: str, lines: List[str]) -> None:
+    try:
+        dir_path = os.path.dirname(path)
+        if dir_path:
+            os.makedirs(dir_path, exist_ok=True)
+        with open(path, "w", encoding="utf-8", newline="\n") as f:
+            f.writelines(lines)
+    except (OSError, PermissionError) as e:
+        raise ApplyError(f"Failed to create directory or write file '{path}': {str(e)}") from e
+    except Exception as e:
+        raise ApplyError(f"Failed to write file '{path}': {str(e)}") from e
+
+def _normalize_repl(repl: str) -> str:
+    if repl == "":
+        return ""
+    return repl if repl.endswith("\n") else (repl + "\n")
+
+def edit_already_satisfied(repo_root: str, e: Dict[str, Any]) -> bool:
+    abs_path = os.path.join(repo_root, e["path"])
+    kind = e["kind"]
+
+    if kind == "create_file":
+        if not os.path.exists(abs_path):
+            return False
+        return _read_text(abs_path) == e.get("replacement", "")
+
+    if not os.path.exists(abs_path):
+        return False
+
+    if kind == "insert":
+        rep = e.get("replacement", "")
+        if rep.strip() == "":
+            return True
+
+        try:
+            current_text = _read_text(abs_path)
+            lines = _read_lines(abs_path)
+            idx = min(int(e.get("after_line", 0)), len(lines))
+            repl = _normalize_repl(rep)
+
+            if repl and idx > 0 and e.get("preserve_indentation", True):
+                if idx < len(lines):
+                    base_indent = get_indentation_level(lines[idx])
+                else:
+                    base_indent = get_indentation_level(lines[idx - 1]) if idx > 0 else 0
+
+                repl_lines = repl.splitlines(keepends=False)
+                if repl_lines:
+                    first_line_indent = get_indentation_level(repl_lines[0])
+                    if first_line_indent == 0 and base_indent > 0:
+                        adjusted_lines = []
+                        for line in repl_lines:
+                            if line.strip():
+                                adjusted_lines.append(" " * base_indent + line)
+                            else:
+                                adjusted_lines.append(line)
+                        repl = "\n".join(adjusted_lines) + ("\n" if repl.endswith("\n") else "")
+
+            return repl in current_text
+        except Exception:
+            return rep in _read_text(abs_path)
+
+    if kind == "delete":
+        lines = _read_lines(abs_path)
+        s = int(e["start_line"]) - 1
+        t = int(e["end_line"])
+        if s < 0 or t < s or t > len(lines):
+            return False
+        if s >= len(lines):
+            return True
+        if s == t:
+            return True
+        return False
+
+    if kind == "replace_file":
+        if not os.path.exists(abs_path):
+            return False
+        current_content = _read_text(abs_path)
+        desired_content = e.get("replacement", "")
+        return current_content == desired_content
+
+    return False
+
+def apply_patchproposal(
+    repo_root: str, 
+    patch: Dict[str, Any],
+    file_access_tracker: Optional['FileAccessTracker'] = None
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    applied: List[Dict[str, Any]] = []
+    skipped: List[Dict[str, Any]] = []
+
+    print(f"\n📝 Applying patch '{patch.get('patch_id', 'unknown')}' with {len(patch.get('edits', []))} edits")
+    print(f"   Repo root: {repo_root}")
+
+    for i, e in enumerate(patch.get("edits", []), 1):
+        abs_path = os.path.join(repo_root, e["path"])
+        file_path = e["path"]
+        kind = e["kind"]
+        
+        if kind == "replace_file":
+            if not e.get("replacement"):
+                raise ApplyError(f"replace_file operation requires non-empty 'replacement' field for {e['path']}")
+        elif kind == "create_file":
+            if not e.get("replacement"):
+                raise ApplyError(f"create_file operation requires non-empty 'replacement' field for {e['path']}")
+        elif kind == "insert":
+            if e.get("after_line") is None:
+                raise ApplyError(f"insert operation requires non-None 'after_line' field for {e['path']}")
+            if not e.get("replacement"):
+                raise ApplyError(f"insert operation requires non-empty 'replacement' field for {e['path']}")
+        elif kind == "delete":
+            if e.get("start_line") is None:
+                raise ApplyError(f"delete operation requires non-None 'start_line' field for {e['path']}")
+            if e.get("end_line") is None:
+                raise ApplyError(f"delete operation requires non-None 'end_line' field for {e['path']}")
+        
+        print(f"\n  Edit {i}/{len(patch.get('edits', []))}: {kind} on {e['path']}")
+        
+        if file_access_tracker:
+            if kind in ["replace_file", "insert", "delete"]:
+                if os.path.exists(abs_path):
+                    if not file_access_tracker.can_edit(file_path):
+                        status = file_access_tracker.get_status(file_path)
+                        raise ApplyError(
+                            f"Cannot edit {file_path}: file not read in full. "
+                            f"Current status: {status}."
+                        )
+        
+        if kind not in ["delete", "replace_file"] and edit_already_satisfied(repo_root, e):
+            skipped.append(e)
+            print(f"  ⏭️  Skipping {kind} edit for {e['path']} (already satisfied)")
+            continue
+
+        if kind == "create_file":
+            overwrite = bool(e.get("overwrite", False))
+            if os.path.exists(abs_path) and not overwrite:
+                print(f"  ⚠️  File '{e['path']}' already exists but overwrite=False. Overwriting anyway.")
+            
+            replacement = e.get("replacement", "")
+            _write_text(abs_path, replacement)
+            
+            if abs_path.endswith('.py') and replacement.strip():
+                is_valid, error_msg = validate_python_syntax(abs_path)
+                if not is_valid:
+                    if os.path.exists(abs_path):
+                        os.remove(abs_path)
+                    raise ApplyError(f"Syntax error in {e['path']} after create_file: {error_msg}")
+            
+            applied.append(e)
+            continue
+
+        if not os.path.exists(abs_path):
+            error_msg = f"{kind} operation failed: File '{e['path']}' does not exist."
+            print(f"  ❌ {error_msg}")
+            raise ApplyError(error_msg)
+
+        if kind == "insert":
+            lines = _read_lines(abs_path)
+            idx = min(int(e.get("after_line", 0)), len(lines))
+            repl = _normalize_repl(e.get("replacement", ""))
+            
+            if repl and idx > 0 and e.get("preserve_indentation", True):
+                if idx < len(lines):
+                    base_indent = get_indentation_level(lines[idx])
+                else:
+                    base_indent = get_indentation_level(lines[idx - 1]) if idx > 0 else 0
+                
+                repl_lines = repl.splitlines(keepends=False)
+                if repl_lines:
+                    first_line_indent = get_indentation_level(repl_lines[0])
+                    if first_line_indent == 0:
+                        adjusted_lines = []
+                        for line in repl_lines:
+                            if line.strip():
+                                adjusted_lines.append(" " * base_indent + line)
+                            else:
+                                adjusted_lines.append(line)
+                        repl = "\n".join(adjusted_lines) + ("\n" if repl.endswith("\n") else "")
+            
+            ins = repl.splitlines(keepends=True) if repl else []
+            
+            original_lines = lines.copy()
+            lines[idx:idx] = ins
+            _write_lines(abs_path, lines)
+            
+            if abs_path.endswith('.py'):
+                is_valid, error_msg = validate_python_syntax(abs_path)
+                if not is_valid:
+                    _write_lines(abs_path, original_lines)
+                    raise ApplyError(f"Syntax error in {e['path']} after insert: {error_msg}")
+            
+            applied.append(e)
+            continue
+
+        if kind == "delete":
+            lines = _read_lines(abs_path)
+            s = int(e["start_line"]) - 1
+            t = int(e["end_line"])
+            if s < 0 or t < s or t > len(lines):
+                raise ApplyError(f"delete out of bounds for {e['path']}: {s+1}-{t} (file has {len(lines)} lines)")
+            
+            if s >= len(lines) or s == t:
+                skipped.append(e)
+                continue
+            
+            original_lines = lines.copy()
+            del lines[s:t]
+            _write_lines(abs_path, lines)
+            
+            if abs_path.endswith('.py'):
+                is_valid, error_msg = validate_python_syntax(abs_path)
+                if not is_valid:
+                    _write_lines(abs_path, original_lines)
+                    raise ApplyError(f"Syntax error in {e['path']} after delete: {error_msg}")
+            
+            applied.append(e)
+            continue
+
+        if kind == "replace_file":
+            if not os.path.exists(abs_path):
+                raise ApplyError(f"replace_file operation failed: File '{e['path']}' does not exist.")
+            
+            replacement = e.get("replacement", "")
+            original_content = _read_text(abs_path)
+            
+            abs_path_obj = Path(abs_path)
+            abs_path_obj.parent.mkdir(parents=True, exist_ok=True)
+            with abs_path_obj.open("w", encoding="utf-8", newline="\n") as f:
+                f.write(replacement)
+            
+            if abs_path.endswith('.py'):
+                is_valid, error_msg = validate_python_syntax(abs_path)
+                if not is_valid:
+                    with abs_path_obj.open("w", encoding="utf-8", newline="\n") as f:
+                        f.write(original_content)
+                    raise ApplyError(f"Syntax error in {e['path']} after replace_file: {error_msg}")
+            
+            applied.append(e)
+            continue
+        
+        raise ApplyError(f"Unsupported kind: {kind}")
+
+    print(f"\n✅ Patch application complete: {len(applied)} applied, {len(skipped)} skipped")
+    return applied, skipped