odooflow-cli 0.1.0__py3-none-any.whl

odooflow/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

odooflow/cli.py

@@ -0,0 +1,105 @@
+import typer
+from typing import List, Optional
+
+from odooflow.commands.init_module_env import init_module_env
+from odooflow.commands.sync_env import sync_env as sync_env_command
+from odooflow.commands.config import config as config_command
+from odooflow.commands.clone_module import clone_module_command
+from odooflow.commands.remote import remote as remote_command
+from odooflow.commands.keygen import generate_ssh_key as keygen_command
+from odooflow.commands.push import push_command
+
+app = typer.Typer(help="OdooFlow CLI — streamline your Odoo development workflow.")
+
+@app.command(name="init")
+def init_manifest(
+    author: Optional[str] = typer.Option(None, help="Author name"),
+    website : Optional[str] = typer.Option(None, help="Website"),
+    odoo_version: Optional[str] = typer.Option(None, help="Odoo version"),
+    license_name: Optional[str] = typer.Option(None, help="License"),
+):
+    """
+    Initialize the Odoo module environment file and sync metadata with manifest.
+    """
+    init_module_env(author=author, odoo_version=odoo_version, license_name=license_name, website=website)
+
+@app.command(name="sync-env")
+def sync_env(
+    keys: Optional[str] = typer.Option(None, "--keys", help="Comma-separated keys to sync from manifest to env file.")
+):
+    """
+    Sync the environment file (.odooflow.env.json) from manifest.
+    """
+    sync_env_command(keys)
+
+@app.command("config", help="Update configuration")
+def config(
+    env_file: Optional[str] = typer.Option(None, help="Set custom env file name"),
+    manifest_file: Optional[str] = typer.Option(None, help="Set custom manifest file name"),
+    access_token : Optional[str] = typer.Option(None, help="Set Git access token"),
+    add_core_module: Optional[str] = typer.Option(None, "--add-core-module", help="Comma-separated list of core modules to add"),
+    sync_keys: Optional[str] = typer.Option(None, help="Set default keys to sync from manifest to .env (comma-separated)"),
+    show: Optional[bool] = typer.Option(False, "--show", help="Show current config")
+):
+    """
+    Update or show OdooFlow CLI configuration (.odooflowrc)
+    """
+    config_command(env_file, manifest_file, access_token, add_core_module, sync_keys,show)
+
+
+@app.command("clone")
+def clone_command(
+    repo_url: str = typer.Argument(..., help="HTTP URL of the module repository."),
+    branch: Optional[str] = typer.Option(None, "--branch", '-b', help="Branch to clone"),
+    depth: int = typer.Option(1, "--depth", "-d", help="Max dependency depth to clone. 1 clones only the target module, 2 clones target + immediate dependencies, etc.")
+):
+    """
+    Clone a module and its dependencies from a git repository.
+    """
+    clone_module_command(repo_url, branch, depth)
+
+
+@app.command()
+def remote(
+    add_repo: Optional[str] = typer.Option(None, help="Add Git remote URL"),
+    branch: Optional[str] = typer.Option(None, help="Target Git branch (defaults to current)"),
+    server_json: Optional[str] = typer.Option(None, help="Server config as JSON: '{\"host\": \"127.0.0.1\", \"port\": 22}'")
+):
+    """
+    Manage remote connections for Git and deployment server.
+    """
+    remote_command(
+        add_repo=add_repo,
+        server_json=server_json, 
+        branch=branch
+    )
+
+@app.command("ssh-keygen")
+def generate_ssh_key(
+    key_name: str = typer.Option("odooflow_rsa", help="Name of the SSH key file to generate (without extension)."),
+    output_dir: Optional[str] = typer.Option(None, help="Directory to save the SSH key. Defaults to ~/.ssh"),
+    overwrite: bool = typer.Option(False, help="Overwrite existing key files if they exist."),
+):
+    """
+    Generate a secure SSH key pair.
+    """
+    keygen_command(key_name=key_name, output_dir=output_dir, overwrite=overwrite)
+
+
+@app.command()
+def push(
+    remote_only: bool = typer.Option(False, "--remote-only", help="Skip Git push and only upload to server"),
+    exec_cmd: Optional[str] = typer.Option(None, "--exec", help="Custom shell command to execute on the server after pushing"),
+):
+    """
+    Push the current Git branch and upload the project to the test server.
+    """
+    push_command(remote_only=remote_only, exec_cmd=exec_cmd)
+
+
+
+def main():
+    app()
+
+if __name__ == "__main__":
+    main()

odooflow/commands/clone_module.py

@@ -0,0 +1,160 @@
+import ast
+import typer
+import requests
+import threading
+
+from typing import Optional
+from concurrent.futures import ThreadPoolExecutor
+
+from urllib.parse import urlparse, urlunparse
+from git import Repo, GitCommandError
+from pathlib import Path
+
+from odooflow.config_manager import get_access_token, get_core_modules_from_config, load_config
+
+
+def get_project_url_from_gitlab(module_name: str, base_url: Optional[str] = None) -> Optional[str]:
+    """
+    Search GitLab for a project by name and return its HTTPS URL.
+    """
+    if base_url is None:
+        config = load_config()
+        base_url = config.get("gitlab_url", "https://gitlab.ebtech-solution.com")
+
+    api_url = f"{base_url}/api/v4/projects"
+    params = {"search": module_name, "simple": "true", "per_page": 100, "access_token": get_access_token()}
+    headers = {"Accept": "application/json"}
+
+    try:
+        typer.secho(f"🔍 Searching GitLab for module: {module_name}", fg="cyan")
+        response = requests.get(api_url, headers=headers, params=params)
+        response.raise_for_status()
+
+        for project in response.json():
+            if project["name"] == module_name or project["path"] == module_name:
+                typer.secho(f"✅ Found module '{module_name}'", fg="green")
+                return project["http_url_to_repo"]
+
+        typer.secho(f"❌ Module '{module_name}' not found in GitLab.", fg="yellow")
+        return None
+
+    except requests.RequestException as e:
+        typer.secho(f"❌ GitLab API error: {e}", fg="red")
+        return None
+
+
+def inject_token_into_url(url: str, token: str) -> str:
+    parsed = urlparse(url)
+    if not parsed.netloc:
+        raise ValueError(f"Invalid URL: {url}")
+    netloc = f"oauth2:{token}@{parsed.netloc}"
+    return urlunparse(parsed._replace(netloc=netloc, scheme="https"))
+
+
+def extract_module_name_from_url(url: str) -> str:
+    return url.rstrip("/").split("/")[-1].removesuffix(".git")
+
+
+def safe_eval_manifest(content: str) -> dict:
+    try:
+        return ast.literal_eval(content)
+    except Exception as e:
+        typer.secho(f"❌ Failed to evaluate manifest: {e}", fg="red")
+        return {}
+
+
+def clone_repo(url: str, target_dir: Path, branch: str = "main") -> bool:
+    if target_dir.exists():
+        typer.secho(f"⚠️  Skipping '{target_dir.name}': already exists.", fg="yellow")
+        return True
+    try:
+        access_token = get_access_token()
+        url_with_token = inject_token_into_url(url, access_token)
+        typer.secho(f"📥 Cloning into '{target_dir}'...", fg="cyan")
+        Repo.clone_from(url_with_token, target_dir, branch=branch)
+        typer.secho(f"✅ Successfully cloned '{url}'", fg="green")
+        return True
+    except GitCommandError as e:
+        typer.secho(f"❌ Git error: Failed to clone '{url}'\n{e}", fg="red")
+        return False
+    except Exception as e:
+        typer.secho(f"❌ Unexpected error: {e}", fg="red")
+        return False
+
+
+def clone_module_command(
+    url: str = typer.Option(..., "--url", help="Full HTTP URL of the module repo."),
+    branch: Optional[str] = None,
+    depth: int = typer.Option(1, "--depth", "-d", help="Max dependency depth to clone. 1 clones only the target module, 2 clones target + immediate dependencies, etc."),
+):
+    """
+    Clone a module and its dependencies into the current directory.
+    """
+    typer.secho("🚀 Starting module cloning process...", fg="cyan", bold=True)
+    core_modules = get_core_modules_from_config()
+    visited = set()
+    fail_count = 0
+    lock = threading.Lock()
+
+    def clone_recursive(module_url: str, current_branch: Optional[str], current_depth: int):
+        nonlocal fail_count
+        module_name = extract_module_name_from_url(module_url)
+
+        with lock:
+            if module_name in visited:
+                typer.secho(f"🔁 Already processed '{module_name}', skipping.", fg="yellow")
+                return False
+            visited.add(module_name)
+
+        target_path = Path.cwd() / module_name
+
+        if not clone_repo(module_url, target_path, current_branch or "main"):
+            typer.secho(f"❌ Failed to clone '{module_name}'. Skipping its dependencies.", fg="red")
+            with lock:
+                fail_count += 1
+            return False
+
+        if current_depth <= 0:
+            return False
+
+        manifest_path = target_path / "__manifest__.py"
+        if not manifest_path.exists():
+            typer.secho(f"📦 No manifest found in '{module_name}', skipping dependencies.", fg="yellow")
+            return True
+
+        manifest_data = safe_eval_manifest(manifest_path.read_text())
+        dependencies = manifest_data.get("depends", [])
+
+        if not dependencies:
+            typer.secho(f"ℹ️  No dependencies for '{module_name}'.", fg="blue")
+            return True
+
+        candidate_deps = [dep for dep in dependencies if dep not in core_modules]
+        if not candidate_deps:
+            return True
+
+        next_depth = current_depth - 1
+
+        def _resolve_and_run(dep_name: str):
+            dep_url = get_project_url_from_gitlab(module_name=dep_name)
+            if not dep_url:
+                typer.secho(f"❗ Could not resolve dependency: '{dep_name}'", fg="red")
+                nonlocal_assign = True
+                with lock:
+                    fail_count += 1
+                return
+            clone_recursive(dep_url, current_branch, next_depth)
+
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = [executor.submit(_resolve_and_run, dep) for dep in candidate_deps]
+            for f in futures:
+                f.result()
+
+        return True
+
+    clone_recursive(url, branch, depth)
+
+    if fail_count > 0:
+        typer.secho(f"⚠️  Finished with {fail_count} failed clones.", fg="yellow", bold=True)
+    else:
+        typer.secho("✅ All done without errors!", fg="green", bold=True)

odooflow/commands/config.py

@@ -0,0 +1,63 @@
+import typer
+from rich import print
+from typing import Optional
+
+from odooflow import config_manager
+
+def config(
+    env_file: str = typer.Option(None),
+    manifest_file: str = typer.Option(None),
+    access_token: str = typer.Option(None),
+    add_core_module: Optional[str] = typer.Option(None),
+    sync_keys: Optional[str] = typer.Option(None),
+    show: bool = typer.Option(False, "--show", help="Display current configuration")
+):
+    current_config = config_manager.load_config()
+    updated = False
+
+    if show:
+        typer.secho("📦 Current Configuration:", fg="cyan", bold=True)
+        print(current_config)
+        raise typer.Exit()
+
+    if env_file:
+        current_config["env_file"] = env_file
+        updated = True
+
+    if manifest_file:
+        current_config["manifest_file"] = manifest_file
+        updated = True
+
+    if access_token:
+        current_config["access_token"] = access_token
+        updated = True
+
+    if add_core_module:
+        modules = [m.strip() for m in add_core_module.split(",") if m.strip()]
+        if modules:
+            existing_modules = set(current_config.get(
+                "core_modules",
+                config_manager.DEFAULT_CONFIG.get("core_modules", [])
+            ))
+            new_modules = set(modules)
+            combined_modules = sorted(existing_modules.union(new_modules))
+            current_config["core_modules"] = combined_modules
+            updated = True
+            typer.secho(f"✅ Added core module(s): {', '.join(new_modules)}", fg="green")
+
+    if sync_keys:
+        new_keys = [k.strip() for k in sync_keys.split(",") if k.strip()]
+        existing_keys = set(current_config.get(
+            "sync_keys",
+            config_manager.DEFAULT_CONFIG['sync_keys'] 
+        ))
+        combined_keys = sorted(existing_keys.union(new_keys))
+        current_config["sync_keys"] = combined_keys
+        updated = True
+        typer.secho(f"🔑 Updated sync keys: {', '.join(new_keys)}", fg="cyan")
+
+    if updated:
+        config_manager.save_config(current_config)
+        typer.secho("💾 Configuration updated successfully.", fg="green")
+    else:
+        typer.secho("⚠️  No changes provided. Use --help to see available options.", fg="yellow")

odooflow/commands/init_module_env.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+from rich import print
+import typer
+
+from odooflow.config_manager import load_config
+from odooflow.utils.env import read_manifest, write_env_file, update_manifest
+
+config = load_config()
+ENV_FILENAME = config["env_file"]
+MANIFEST_FILENAME = config["manifest_file"]
+
+
+
+def init_module_env(author: str, odoo_version: str, license_name: str, website : str):
+    cwd = Path.cwd()
+    env_path = cwd / ENV_FILENAME
+    manifest_path = cwd / MANIFEST_FILENAME
+
+    if not manifest_path.exists():
+        print(f"[red]No {MANIFEST_FILENAME} found in this directory[/red]")
+        raise SystemExit(1)
+
+    manifest = read_manifest(manifest_path)
+
+    values = {
+        "name" : manifest.get("name", ""),
+        "author": author or typer.prompt("Author", default=manifest.get("author", "Unknown")),
+        "version": odoo_version or typer.prompt("Odoo version", default=manifest.get("version", "16.0")),
+        "license": license_name or typer.prompt("License", default=manifest.get("license", "LGPL-3")),
+        "website" : website or typer.prompt("Website", default=manifest.get("website", 'https://www.yourcompany.com')),
+        "depends" : manifest.get("depends" , []),
+    }
+
+    write_env_file(env_path, values)
+
+    if author or odoo_version or license_name or website:
+        update_manifest(manifest_path, values)

odooflow/commands/keygen.py

@@ -0,0 +1,56 @@
+import platform
+import typer
+from pathlib import Path
+from typing import Optional
+import subprocess
+
+
+DEFAULT_COMMENT = "odooflow"
+
+def generate_ssh_key(
+    key_name: str = typer.Option(),
+    output_dir: Optional[str] = typer.Option(),
+    overwrite: bool = typer.Option(),
+    passphrase: Optional[str] = typer.Option(None, help="Passphrase for the SSH key"),
+):
+    typer.secho("🔐 Generating SSH key pair...", fg="cyan")
+
+    home = Path.home()
+    ssh_dir = Path(output_dir).expanduser() if output_dir else home / ".ssh"
+    ssh_dir.mkdir(parents=True, exist_ok=True)
+
+    private_key_path = ssh_dir / key_name
+    public_key_path = ssh_dir / f"{key_name}.pub"
+
+    if private_key_path.exists() or public_key_path.exists():
+        if not overwrite:
+            typer.secho(f"❌ Key files already exist at {private_key_path}.", fg="red")
+            typer.secho("Use --overwrite to replace them.", fg="yellow")
+            raise typer.Exit()
+
+    os_name = platform.system()
+
+    try:
+        if os_name in ["Linux", "Darwin", "Windows"]:
+            # Use ssh-keygen if available
+            command = [
+                "ssh-keygen",
+                "-t", "rsa",
+                "-b", "4096",
+                "-f", str(private_key_path),
+                "-C", DEFAULT_COMMENT,
+                "-N", passphrase if passphrase else "",
+            ]
+            subprocess.run(command, check=True)
+        else:
+            typer.secho(f"❌ Unsupported OS: {os_name}", fg="red")
+            raise typer.Exit()
+
+        typer.secho(f"✅ SSH key pair generated:", fg="green")
+        typer.echo(f"🔑 Private key: {private_key_path}")
+        typer.echo(f"🔓 Public key: {public_key_path}")
+
+    except FileNotFoundError:
+        typer.secho("❌ ssh-keygen not found on your system. Please install OpenSSH.", fg="red")
+    except subprocess.CalledProcessError as e:
+        typer.secho(f"❌ Failed to generate SSH key: {e}", fg="red")

odooflow/commands/push.py

@@ -0,0 +1,132 @@
+import typer
+from pathlib import Path
+from typing import Optional
+from git import Repo, GitCommandError
+import getpass
+
+from odooflow import config_manager
+from odooflow.utils.env import read_env_file
+from odooflow.utils.ssh import upload_directory_via_ssh
+
+
+EXCLUDED_DIRS = {".git", "__pycache__", ".venv", "node_modules", ".mypy_cache", ".pytest_cache", ".env", ".odooflowrc", ".odooflow.env.json"}
+
+def get_gitignore_exclusions(base_path: Path):
+    gitignore_path = base_path / ".gitignore"
+    exclusions = set()
+
+    if not gitignore_path.exists():
+        return exclusions
+
+    with gitignore_path.open("r") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+
+            if "/" in line or "*" in line:
+                continue  # Skip wildcards and nested ignores for now
+
+            exclusions.add(line.strip("/"))
+
+    return exclusions
+
+
+
+def push_command(remote_only: bool = False, exec_cmd: Optional[str] = None):
+    cwd = Path.cwd()
+
+    # Load config and env
+    config = config_manager.load_config()
+    env_path = cwd / config.get("env_file", ".env")
+    env = read_env_file(env_path)
+
+    excluded_dirs = EXCLUDED_DIRS.union(get_gitignore_exclusions(cwd))
+
+    module_name = env.get("name")
+    if not module_name:
+        typer.secho("❌ Module name not found in environment file.", fg="red")
+        raise typer.Exit(1)
+
+    remote_config = env.get("remotes", {})
+    if not remote_config:
+        typer.secho(f"❌ No remote config found for module: {module_name}", fg="red")
+        raise typer.Exit(1)
+
+    # Git Push (if not remote only)
+    if not remote_only:
+        repo_config = remote_config.get("repo", {})
+        if not repo_config:
+            typer.secho(f"❌ No repo config provided", fg="red")
+            raise typer.Exit(1)
+        repo_url = remote_config.get("repo")
+        branch = remote_config.get("branch")
+
+        try:
+            repo = Repo(cwd)
+            if repo.head.is_detached:
+                typer.secho("❌ Git repository is in a detached HEAD state. Cannot push.", fg="red")
+                raise typer.Exit(1)
+            active_branch = repo.active_branch.name
+            branch_to_push = branch or active_branch
+
+            typer.secho(f"🚀 Pushing branch '{branch_to_push}' to remote...", fg="cyan")
+            origin = repo.remote(name="origin")
+            origin.push(refspec=f"{branch_to_push}:{branch_to_push}")
+            typer.secho("✅ Git push successful.", fg="green")
+        except GitCommandError as e:
+            typer.secho(f"❌ Git error: {e}", fg="red")
+            raise typer.Exit(1)
+        except Exception as e:
+            typer.secho(f"❌ Unexpected Git error: {e}", fg="red")
+            raise typer.Exit(1)
+    else:
+        typer.secho("📦 Skipping Git push (remote only mode).", fg="yellow")
+
+    # Upload to server
+    server = remote_config.get("server")
+    if not server:
+        typer.secho("⚠️  No server config found for this module. Skipping upload.", fg="yellow")
+        raise typer.Exit(0)
+
+    required_keys = ["host", "user", "directory"]
+    if not all(k in server for k in required_keys):
+        typer.secho(f"❌ Incomplete server config. Required keys: {', '.join(required_keys)}", fg="red")
+        raise typer.Exit(1)
+
+    key_path = server.get("key") or server.get("key_path")
+    password = server.get("password")
+    if not key_path and not password:
+        password = getpass.getpass("🔑 Enter SSH password: ")
+
+    final_exec_cmd = exec_cmd or server.get("post_push_cmd")
+
+    def _report_post_exec(stdout_text: str, stderr_text: str, exit_status: int):
+        if stdout_text:
+            typer.secho(stdout_text, fg="cyan")
+        if exit_status != 0:
+            typer.secho(
+                f"❌ Post-upload command failed (exit {exit_status}): {stderr_text.strip() or '(no stderr)'}",
+                fg="red",
+                bold=True,
+            )
+            raise typer.Exit(1)
+
+    try:
+        typer.secho("📤 Uploading project to the test server...", fg="cyan")
+        upload_directory_via_ssh(
+            local_path=cwd,
+            remote_user=server["user"],
+            remote_host=server["host"],
+            remote_path=server["directory"],
+            port=int(server.get("port", 22)),
+            key_path=key_path,
+            password=password,
+            exclude_dirs=excluded_dirs,
+            post_exec_cmd=final_exec_cmd,
+            on_post_exec=_report_post_exec if final_exec_cmd else None,
+        )
+        typer.secho("✅ Project uploaded successfully.", fg="green")
+    except Exception as e:
+        typer.secho(f"❌ Upload failed: {e}", fg="red")
+        raise typer.Exit(1)