orkestr-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{orkestr_cli-0.2.0 → orkestr_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orkestr-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: CLI for the Orkestr deployment platform
 Author-email: Orkestr <hello@orkestr.eu>
 License-Expression: MIT
@@ -39,28 +39,35 @@ pip install orkestr-cli
 # Authenticate with your API token
 orkestr login
 
-# List your projects
-orkestr projects list
+# From inside your app's git repo: detect name/repo/branch and create the project
+orkestr init
 
-# Deploy
+# Build, deploy, and wait for the live URL
+orkestr deploy .
+
+# ...or deploy a named project
 orkestr deploy my-api
 
-# View logs
+# View logs / check health
 orkestr logs my-api
-
-# Check health
 orkestr health my-api
 ```
 
+`orkestr init` writes a gitignored `.orkestr/config.json` linking the
+directory to the project, so `orkestr deploy .` knows what to ship. It needs
+an orkestr account and the repo's git provider (GitHub, GitLab, Bitbucket, or
+Codeberg) connected to that account.
+
 ## Commands
 
 | Command | Description |
 |---|---|
 | `orkestr login` / `logout` / `whoami` | Auth |
+| `orkestr init` | Link the current directory to a new project (interactive) |
 | `orkestr projects list\|create\|show\|update\|delete\|analyze` | Manage projects |
 | `orkestr projects env-vars\|webhook\|webhook-toggle <project>` | Project env vars + git webhook |
 | `orkestr envs list\|create\|update\|delete\|env-vars` | Manage environments |
-| `orkestr deploy <project>` | Trigger a deployment |
+| `orkestr deploy [project]` | Build + deploy, stream the pipeline, print the live URL (`.` = linked dir; `--detach` to not wait) |
 | `orkestr deployments list\|show\|logs\|build-log\|rollback` | Deployment history |
 | `orkestr functions list\|show\|create\|update\|deploy\|delete` | Serverless functions |
 | `orkestr functions logs\|invoke\|env-vars\|metrics\|rotate-key` | Function ops |

{orkestr_cli-0.2.0 → orkestr_cli-0.3.0}/README.md

@@ -14,28 +14,35 @@ pip install orkestr-cli
 # Authenticate with your API token
 orkestr login
 
-# List your projects
-orkestr projects list
+# From inside your app's git repo: detect name/repo/branch and create the project
+orkestr init
 
-# Deploy
+# Build, deploy, and wait for the live URL
+orkestr deploy .
+
+# ...or deploy a named project
 orkestr deploy my-api
 
-# View logs
+# View logs / check health
 orkestr logs my-api
-
-# Check health
 orkestr health my-api
 ```
 
+`orkestr init` writes a gitignored `.orkestr/config.json` linking the
+directory to the project, so `orkestr deploy .` knows what to ship. It needs
+an orkestr account and the repo's git provider (GitHub, GitLab, Bitbucket, or
+Codeberg) connected to that account.
+
 ## Commands
 
 | Command | Description |
 |---|---|
 | `orkestr login` / `logout` / `whoami` | Auth |
+| `orkestr init` | Link the current directory to a new project (interactive) |
 | `orkestr projects list\|create\|show\|update\|delete\|analyze` | Manage projects |
 | `orkestr projects env-vars\|webhook\|webhook-toggle <project>` | Project env vars + git webhook |
 | `orkestr envs list\|create\|update\|delete\|env-vars` | Manage environments |
-| `orkestr deploy <project>` | Trigger a deployment |
+| `orkestr deploy [project]` | Build + deploy, stream the pipeline, print the live URL (`.` = linked dir; `--detach` to not wait) |
 | `orkestr deployments list\|show\|logs\|build-log\|rollback` | Deployment history |
 | `orkestr functions list\|show\|create\|update\|deploy\|delete` | Serverless functions |
 | `orkestr functions logs\|invoke\|env-vars\|metrics\|rotate-key` | Function ops |

{orkestr_cli-0.2.0 → orkestr_cli-0.3.0}/orkestr_cli/api.py

@@ -97,7 +97,7 @@ def list_projects(skip: int = 0, limit: int = 20) -> dict:
 
 def create_project(name: str, repo_url: str, branch: str = "main",
                    display_name: str | None = None, description: str | None = None,
-                   env_vars: dict | None = None) -> dict:
+                   env_vars: dict | None = None, build_context: str | None = None) -> dict:
     payload = {"name": name, "repo_url": repo_url, "repo_branch": branch}
     if display_name:
         payload["display_name"] = display_name
@@ -105,9 +105,21 @@ def create_project(name: str, repo_url: str, branch: str = "main",
         payload["description"] = description
     if env_vars:
         payload["env_vars"] = env_vars
+    if build_context:
+        payload["build_context"] = build_context
     return _post("/api/v1/projects", json=payload)
 
 
+def detect_services(repo_url: str, branch: str = "main") -> dict:
+    """Detect deployable services in a repo (monorepo support).
+
+    Note: detect-services is served under /api/projects (not the /api/v1
+    prefix the rest of these calls use) — confirmed against the live API.
+    """
+    return _post("/api/projects/detect-services",
+                 params={"repo_url": repo_url, "branch": branch})
+
+
 def get_project(project_id: str) -> dict:
     return _get(f"/api/v1/projects/{project_id}")
 

orkestr_cli-0.3.0/orkestr_cli/gitinfo.py

@@ -0,0 +1,108 @@
+"""Read repo metadata straight from a local .git directory.
+
+No git binary required — init only needs the origin URL and current branch,
+both of which are plain text in .git/config and .git/HEAD. Parsing them
+ourselves keeps init working in containers and minimal images that ship
+without the git CLI.
+"""
+
+import re
+from pathlib import Path
+
+
+def find_git_root(start: Path | None = None) -> Path | None:
+    """Walk up from start (default cwd) to the directory containing .git."""
+    path = (start or Path.cwd()).resolve()
+    for candidate in [path, *path.parents]:
+        if (candidate / ".git").exists():
+            return candidate
+    return None
+
+
+def normalize_remote_url(url: str) -> str:
+    """Normalize any git remote URL to an https:// clone URL.
+
+    Handles the three forms a remote shows up as:
+      git@github.com:user/repo.git        (scp-like ssh)
+      ssh://git@github.com/user/repo.git   (ssh url)
+      https://github.com/user/repo.git     (already https)
+    The trailing .git and any embedded credentials are stripped.
+    """
+    url = url.strip()
+
+    # scp-like: [user@]host:path
+    m = re.match(r"^(?:ssh://)?(?:[^@/]+@)?([^:/]+):(.+?)(?:\.git)?/?$", url)
+    if m and "://" not in url:
+        return f"https://{m.group(1)}/{m.group(2)}"
+
+    # ssh://[user@]host[:port]/path
+    m = re.match(r"^ssh://(?:[^@/]+@)?([^/:]+)(?::\d+)?/(.+?)(?:\.git)?/?$", url)
+    if m:
+        return f"https://{m.group(1)}/{m.group(2)}"
+
+    # http(s)://[user[:pass]@]host/path  — strip creds + trailing .git
+    m = re.match(r"^(https?://)(?:[^@/]+@)?(.+?)(?:\.git)?/?$", url)
+    if m:
+        return f"{m.group(1)}{m.group(2)}"
+
+    return url
+
+
+def read_origin_url(git_root: Path) -> str | None:
+    """Return the normalized origin remote URL, or the first remote found.
+
+    Parses .git/config by hand rather than via configparser: git indents
+    entries with tabs, which configparser misreads as value continuations.
+    """
+    cfg = git_root / ".git" / "config"
+    if not cfg.exists():
+        return None
+
+    remotes: dict[str, str] = {}
+    current_remote: str | None = None
+    for raw in cfg.read_text(errors="replace").splitlines():
+        line = raw.strip()
+        if line.startswith("[") and line.endswith("]"):
+            section = line[1:-1].strip()
+            if section.startswith("remote "):
+                # [remote "origin"] -> origin
+                current_remote = section.split('"')[1] if '"' in section else section[7:].strip()
+            else:
+                current_remote = None
+            continue
+        if current_remote and "=" in line:
+            key, _, value = line.partition("=")
+            if key.strip().lower() == "url" and value.strip():
+                remotes[current_remote] = normalize_remote_url(value.strip())
+
+    return remotes.get("origin") or next(iter(remotes.values()), None)
+
+
+def read_current_branch(git_root: Path) -> str | None:
+    """Return the checked-out branch name, or None if detached."""
+    head = git_root / ".git" / "HEAD"
+    if not head.exists():
+        return None
+    text = head.read_text(errors="replace").strip()
+    if text.startswith("ref:"):
+        # ref: refs/heads/main -> main
+        return text.split("refs/heads/", 1)[-1] if "refs/heads/" in text else None
+    return None
+
+
+def slugify(name: str) -> str:
+    """Derive a valid orkestr project slug from a directory name.
+
+    Slugs must match ^[a-z0-9][a-z0-9-]*$ and be 2-100 chars. Lowercases,
+    replaces runs of non-alphanumerics with a single hyphen, trims hyphens,
+    and pads to the 2-char minimum.
+    """
+    slug = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+    slug = re.sub(r"-{2,}", "-", slug)
+    if not slug:
+        slug = "app"
+    if not slug[0].isalnum():
+        slug = "a" + slug
+    if len(slug) < 2:
+        slug = (slug + "-app")[:100]
+    return slug[:100]

orkestr_cli-0.3.0/orkestr_cli/localconfig.py

@@ -0,0 +1,62 @@
+"""Project-local config: ./.orkestr/config.json.
+
+`orkestr init` writes this file to tie the current directory to an orkestr
+project, so `orkestr deploy .` knows what "." means. It is gitignored
+(local-only, per-developer) — distinct from the global ~/.orkestr/config.json
+that holds credentials and the API URL.
+"""
+
+import json
+from pathlib import Path
+
+LOCAL_DIR_NAME = ".orkestr"
+LOCAL_FILE_NAME = "config.json"
+
+
+def local_dir(root: Path | None = None) -> Path:
+    return (root or Path.cwd()) / LOCAL_DIR_NAME
+
+
+def find_local_config(start: Path | None = None) -> Path | None:
+    """Walk up from start (default cwd) to find a .orkestr/config.json."""
+    path = (start or Path.cwd()).resolve()
+    for candidate in [path, *path.parents]:
+        cfg = candidate / LOCAL_DIR_NAME / LOCAL_FILE_NAME
+        if cfg.exists():
+            return cfg
+    return None
+
+
+def load_local(start: Path | None = None) -> dict | None:
+    """Load the nearest project-local config, or None if there isn't one."""
+    path = find_local_config(start)
+    if not path:
+        return None
+    try:
+        return json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def write_local(data: dict, root: Path | None = None) -> Path:
+    """Write .orkestr/config.json under root (default cwd) and gitignore it."""
+    root = root or Path.cwd()
+    directory = local_dir(root)
+    directory.mkdir(parents=True, exist_ok=True)
+    path = directory / LOCAL_FILE_NAME
+    path.write_text(json.dumps(data, indent=2) + "\n")
+    _ensure_gitignored(root)
+    return path
+
+
+def _ensure_gitignored(root: Path) -> None:
+    """Add `.orkestr/` to the repo's .gitignore if not already ignored."""
+    gitignore = root / ".gitignore"
+    entry = f"{LOCAL_DIR_NAME}/"
+    lines = gitignore.read_text().splitlines() if gitignore.exists() else []
+    if any(line.strip() in (entry, LOCAL_DIR_NAME) for line in lines):
+        return
+    with gitignore.open("a") as f:
+        if lines and lines[-1].strip():
+            f.write("\n")
+        f.write(f"# orkestr CLI local project config\n{entry}\n")

{orkestr_cli-0.2.0 → orkestr_cli-0.3.0}/orkestr_cli/main.py

@@ -1,8 +1,11 @@
 """Orkestr CLI — manage your projects, deployments, and infrastructure."""
 
+import time
+from pathlib import Path
+
 import click
 
-from orkestr_cli import api, config
+from orkestr_cli import api, config, gitinfo, localconfig
 from orkestr_cli.output import (
     console,
     format_dt,
@@ -22,7 +25,7 @@ from orkestr_cli.output import (
 @click.option("--api-url", envvar="ORKESTR_API_URL", help="Override API base URL.")
 @click.option("--token", envvar="ORKESTR_API_TOKEN", help="API token for auth.")
 @click.option("--json", "use_json", is_flag=True, help="Output raw JSON.")
-@click.version_option("0.2.0", prog_name="orkestr")
+@click.version_option("0.3.0", prog_name="orkestr")
 @click.pass_context
 def cli(ctx, api_url, token, use_json):
     """Orkestr CLI — deploy and manage your applications."""
@@ -464,22 +467,278 @@ def addons_delete_backup(project, addon_id, backup_id):
 # ---------------------------------------------------------------------------
 
 @cli.command()
-@click.argument("project")
+@click.argument("project", required=False)
 @click.option("--env", "environment_id", help="Environment ID (defaults to production).")
+@click.option("--detach", "-d", is_flag=True,
+              help="Trigger and return immediately, without waiting (for CI).")
+@click.option("--timeout", default=600, show_default=True,
+              help="Max seconds to wait for the deploy to finish.")
 @click.pass_context
-def deploy(ctx, project, environment_id):
-    """Trigger a deployment."""
-    project_id = api.resolve_project_id(project)
+def deploy(ctx, project, environment_id, detach, timeout):
+    """Build and deploy a project, waiting until it's live.
+
+    PROJECT is a project name. Pass "." (or omit it) to deploy the project
+    linked to the current directory by 'orkestr init'. Use --detach to fire
+    the deploy and return immediately without streaming the pipeline.
+    """
+    project_id = _resolve_deploy_target(project)
     data = api.trigger_deployment(project_id, environment_id)
+    deployment_id = data["id"]
+
+    if detach:
+        if ctx.obj["json"]:
+            print_json(data)
+            return
+        click.secho("Deployment triggered.", fg="green")
+        print_kv([
+            ("Deployment ID:", deployment_id),
+            ("Status:", data.get("status", "-")),
+        ])
+        click.echo(f"\nTrack progress: orkestr deployments show {deployment_id}")
+        return
+
+    final = _wait_for_deployment(deployment_id, timeout, json_mode=ctx.obj["json"])
+
     if ctx.obj["json"]:
-        print_json(data)
+        print_json(final)
+        if final.get("status") != "live":
+            raise SystemExit(1)
         return
-    click.secho("Deployment triggered.", fg="green")
+
+    click.echo()
+    if final.get("status") == "live":
+        domain = _project_domain(project_id)
+        if domain:
+            click.secho(f"  Live at https://{domain}", fg="green", bold=True)
+        else:
+            click.secho("  Deployment live.", fg="green", bold=True)
+    else:
+        click.secho("  Deployment failed.", fg="red", bold=True)
+        click.echo(f"  See logs: orkestr deployments logs {deployment_id}")
+        raise SystemExit(1)
+
+
+def _resolve_deploy_target(project: str | None) -> str:
+    """Resolve a deploy target to a project id, honoring ./.orkestr/config.json.
+
+    `.` (or no argument) means "the project linked to this directory". This
+    short-circuits before resolve_project_id, which would otherwise treat "."
+    as a name and fail to find it.
+    """
+    if project in (None, "", "."):
+        cfg = localconfig.load_local()
+        if not cfg or not cfg.get("project"):
+            click.secho(
+                "No orkestr project linked to this directory. "
+                "Run 'orkestr init' first, or pass a project name.",
+                fg="red", err=True,
+            )
+            raise SystemExit(1)
+        # The stored project_id is canonical — use it directly rather than
+        # round-tripping through the name/UUID heuristic in resolve_project_id.
+        if cfg.get("project_id"):
+            return cfg["project_id"]
+        return api.resolve_project_id(cfg["project"])
+    return api.resolve_project_id(project)
+
+
+def _wait_for_deployment(deployment_id: str, timeout: int, json_mode: bool) -> dict:
+    """Poll a deployment until it is live or failed, streaming step transitions."""
+    seen: dict[str, str] = {}
+    waited = 0
+    interval = 2
+    while True:
+        data = api.get_deployment(deployment_id)
+        if not json_mode:
+            _render_step_transitions(data.get("steps", []), seen)
+        if data.get("status") in ("live", "failed"):
+            return data
+        if waited >= timeout:
+            if not json_mode:
+                click.secho(f"\n  Timed out after {timeout}s.", fg="yellow")
+            return data
+        time.sleep(interval)
+        waited += interval
+
+
+def _render_step_transitions(steps: list, seen: dict) -> None:
+    """Print a line each time a pipeline step changes state."""
+    for s in steps:
+        name = s.get("step_name", "")
+        status = s.get("status", "")
+        if not name or seen.get(name) == status:
+            continue
+        seen[name] = status
+        if status == "running":
+            click.secho(f"  > {name} ...", fg="cyan")
+        elif status == "completed":
+            click.secho(f"  OK   {name}", fg="green")
+        elif status == "failed":
+            click.secho(f"  FAIL {name}", fg="red")
+
+
+def _project_domain(project_id: str) -> str | None:
+    """Best-effort fetch of a project's live domain (not on the deployment payload)."""
+    try:
+        return api.get_project(project_id).get("domain")
+    except SystemExit:
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Init (interactive project setup)
+# ---------------------------------------------------------------------------
+
+@cli.command()
+@click.option("--dir", "directory", default=".", type=click.Path(file_okay=False),
+              help="Project directory (default: current).")
+@click.option("--name", help="Project name (slug). Default: derived from the directory.")
+@click.option("--repo", help="Git repository URL. Default: the origin remote in .git.")
+@click.option("--branch", help="Branch to deploy. Default: the current branch.")
+@click.option("--yes", "-y", "assume_yes", is_flag=True,
+              help="Accept all detected defaults without prompting.")
+@click.pass_context
+def init(ctx, directory, name, repo, branch, assume_yes):
+    """Link this directory to a new orkestr project, interactively.
+
+    Detects the project name, git repo, and branch from the directory, lets
+    you confirm each with Enter, picks the service for monorepos, creates the
+    project, and writes .orkestr/config.json so you can then 'orkestr deploy .'.
+    """
+    if not config.is_logged_in():
+        click.secho("Not logged in. Run: orkestr login", fg="red", err=True)
+        raise SystemExit(1)
+    user = api.me()
+
+    root = Path(directory).resolve()
+    if not root.is_dir():
+        click.secho(f"Not a directory: {root}", fg="red", err=True)
+        raise SystemExit(1)
+
+    existing = localconfig.load_local(root)
+    if existing and existing.get("project"):
+        click.secho(f"This directory is already linked to '{existing['project']}'.",
+                    fg="yellow")
+        if not assume_yes and not click.confirm("Re-initialize and overwrite?", default=False):
+            raise SystemExit(0)
+
+    git_root = gitinfo.find_git_root(root)
+    default_name = gitinfo.slugify(name or root.name)
+    default_repo = repo or (gitinfo.read_origin_url(git_root) if git_root else None)
+    default_branch = (
+        branch or (gitinfo.read_current_branch(git_root) if git_root else None) or "main"
+    )
+
+    click.secho(f"Initializing orkestr project in {root}", bold=True)
+    click.echo(f"Logged in as {user.get('username', 'unknown')}.\n")
+
+    project_name = _prompt_project_name(name or default_name, assume_yes)
+
+    project_repo = repo or default_repo
+    if not assume_yes:
+        project_repo = click.prompt(
+            "Git repository", default=default_repo or "",
+            show_default=bool(default_repo),
+        ).strip()
+    if not project_repo:
+        click.secho("A git repository URL is required (no origin remote found).",
+                    fg="red", err=True)
+        raise SystemExit(1)
+
+    project_branch = branch or default_branch
+    if not assume_yes:
+        project_branch = click.prompt("Branch", default=default_branch).strip()
+
+    build_context = _pick_service(project_repo, project_branch, assume_yes)
+
+    dns = f"{project_name}.orkestr.run"
+    click.echo()
     print_kv([
-        ("Deployment ID:", data["id"]),
-        ("Status:", data.get("status", "-")),
+        ("Name:", project_name),
+        ("Repo:", project_repo),
+        ("Branch:", project_branch),
+        ("Service:", build_context or "(repo root)"),
+        ("DNS:", dns),
     ])
-    click.echo(f"\nTrack progress: orkestr deployments show {data['id']}")
+    if not assume_yes and not click.confirm("\nCreate this project?", default=True):
+        click.secho("Aborted.", fg="yellow")
+        raise SystemExit(0)
+
+    # display_name must be >= 2 chars server-side; a 1-char dir name would 422.
+    display_name = root.name if len(root.name) >= 2 else project_name
+    data = api.create_project(
+        name=project_name,
+        repo_url=project_repo,
+        branch=project_branch,
+        display_name=display_name,
+        build_context=build_context,
+    )
+    localconfig.write_local({
+        "project": data["name"],
+        "project_id": data["id"],
+        "branch": project_branch,
+        "build_context": build_context or ".",
+    }, root=root)
+
+    click.echo()
+    click.secho(f"Project '{data['name']}' created and linked.", fg="green")
+    print_kv([
+        ("Domain:", data.get("domain") or dns),
+        ("Config:", ".orkestr/config.json"),
+    ])
+    click.echo("\nNext: orkestr deploy .")
+
+
+def _prompt_project_name(default_name: str, assume_yes: bool) -> str:
+    """Prompt for a project name and ensure the slug is valid and available."""
+    name = gitinfo.slugify(default_name)
+    while True:
+        if not assume_yes:
+            name = gitinfo.slugify(click.prompt("Project name", default=name))
+        check = api.project_check_name(name)
+        if check.get("available"):
+            return name
+        reason = "reserved" if check.get("reason") == "reserved" else "already taken"
+        click.secho(f"  '{name}' is {reason}.", fg="yellow")
+        if assume_yes:
+            for i in range(2, 100):
+                candidate = gitinfo.slugify(f"{default_name}-{i}")
+                if api.project_check_name(candidate).get("available"):
+                    click.secho(f"  Using '{candidate}'.", fg="cyan")
+                    return candidate
+            click.secho("Could not find an available name.", fg="red", err=True)
+            raise SystemExit(1)
+        name = gitinfo.slugify(f"{name}-2")
+
+
+def _pick_service(repo_url: str, branch: str, assume_yes: bool) -> str | None:
+    """Detect deployable services; return the chosen build_context (None = root)."""
+    click.echo("  Scanning the repo for services ...")
+    try:
+        resp = api.detect_services(repo_url, branch)
+    except SystemExit:
+        click.secho("  Could not scan the repo; defaulting to the repo root.",
+                    fg="yellow")
+        return None
+    services = resp.get("services", []) if isinstance(resp, dict) else []
+
+    if len(services) <= 1:
+        only = services[0] if services else None
+        if only and only.get("path") not in (".", "", None):
+            return only.get("path")
+        return None
+
+    click.echo("\n  Multiple services detected:")
+    for i, s in enumerate(services, 1):
+        click.echo(f"    {i}. {s.get('path')}  ({s.get('framework') or 'unknown'})")
+    if assume_yes:
+        chosen = services[0]
+        click.secho(f"  Using '{chosen.get('path')}' (first match).", fg="cyan")
+        path = chosen.get("path")
+        return None if path in (".", "") else path
+    idx = click.prompt("  Pick a service", type=click.IntRange(1, len(services)), default=1)
+    path = services[idx - 1].get("path")
+    return None if path in (".", "") else path
 
 
 # ---------------------------------------------------------------------------

{orkestr_cli-0.2.0 → orkestr_cli-0.3.0}/orkestr_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orkestr-cli
-Version: 0.2.0
+Version: 0.3.0
 Summary: CLI for the Orkestr deployment platform
 Author-email: Orkestr <hello@orkestr.eu>
 License-Expression: MIT
@@ -39,28 +39,35 @@ pip install orkestr-cli
 # Authenticate with your API token
 orkestr login
 
-# List your projects
-orkestr projects list
+# From inside your app's git repo: detect name/repo/branch and create the project
+orkestr init
 
-# Deploy
+# Build, deploy, and wait for the live URL
+orkestr deploy .
+
+# ...or deploy a named project
 orkestr deploy my-api
 
-# View logs
+# View logs / check health
 orkestr logs my-api
-
-# Check health
 orkestr health my-api
 ```
 
+`orkestr init` writes a gitignored `.orkestr/config.json` linking the
+directory to the project, so `orkestr deploy .` knows what to ship. It needs
+an orkestr account and the repo's git provider (GitHub, GitLab, Bitbucket, or
+Codeberg) connected to that account.
+
 ## Commands
 
 | Command | Description |
 |---|---|
 | `orkestr login` / `logout` / `whoami` | Auth |
+| `orkestr init` | Link the current directory to a new project (interactive) |
 | `orkestr projects list\|create\|show\|update\|delete\|analyze` | Manage projects |
 | `orkestr projects env-vars\|webhook\|webhook-toggle <project>` | Project env vars + git webhook |
 | `orkestr envs list\|create\|update\|delete\|env-vars` | Manage environments |
-| `orkestr deploy <project>` | Trigger a deployment |
+| `orkestr deploy [project]` | Build + deploy, stream the pipeline, print the live URL (`.` = linked dir; `--detach` to not wait) |
 | `orkestr deployments list\|show\|logs\|build-log\|rollback` | Deployment history |
 | `orkestr functions list\|show\|create\|update\|deploy\|delete` | Serverless functions |
 | `orkestr functions logs\|invoke\|env-vars\|metrics\|rotate-key` | Function ops |

{orkestr_cli-0.2.0 → orkestr_cli-0.3.0}/orkestr_cli.egg-info/SOURCES.txt

@@ -3,6 +3,8 @@ pyproject.toml
 orkestr_cli/__init__.py
 orkestr_cli/api.py
 orkestr_cli/config.py
+orkestr_cli/gitinfo.py
+orkestr_cli/localconfig.py
 orkestr_cli/main.py
 orkestr_cli/output.py
 orkestr_cli.egg-info/PKG-INFO
@@ -10,4 +12,5 @@ orkestr_cli.egg-info/SOURCES.txt
 orkestr_cli.egg-info/dependency_links.txt
 orkestr_cli.egg-info/entry_points.txt
 orkestr_cli.egg-info/requires.txt
-orkestr_cli.egg-info/top_level.txt
+orkestr_cli.egg-info/top_level.txt
+tests/test_gitinfo.py

{orkestr_cli-0.2.0 → orkestr_cli-0.3.0}/orkestr_cli.egg-info/top_level.txt

@@ -1,2 +1 @@
-dist
 orkestr_cli

{orkestr_cli-0.2.0 → orkestr_cli-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orkestr-cli"
-version = "0.2.0"
+version = "0.3.0"
 description = "CLI for the Orkestr deployment platform"
 readme = "README.md"
 license = "MIT"
@@ -40,3 +40,4 @@ orkestr = "orkestr_cli.main:cli"
 
 [tool.setuptools.packages.find]
 where = ["."]
+include = ["orkestr_cli*"]

orkestr_cli-0.3.0/tests/test_gitinfo.py

@@ -0,0 +1,110 @@
+"""Tests for the pure git-metadata + slug helpers in gitinfo."""
+
+from orkestr_cli import gitinfo
+
+
+class TestNormalizeRemoteUrl:
+    def test_scp_like_ssh(self):
+        assert (gitinfo.normalize_remote_url("git@github.com:user/repo.git")
+                == "https://github.com/user/repo")
+
+    def test_scp_like_no_dot_git(self):
+        assert (gitinfo.normalize_remote_url("git@gitlab.com:group/sub/repo")
+                == "https://gitlab.com/group/sub/repo")
+
+    def test_ssh_url(self):
+        assert (gitinfo.normalize_remote_url("ssh://git@github.com/user/repo.git")
+                == "https://github.com/user/repo")
+
+    def test_ssh_url_with_port(self):
+        assert (gitinfo.normalize_remote_url("ssh://git@example.com:2222/user/repo.git")
+                == "https://example.com/user/repo")
+
+    def test_https_strips_dot_git(self):
+        assert (gitinfo.normalize_remote_url("https://github.com/user/repo.git")
+                == "https://github.com/user/repo")
+
+    def test_https_already_clean(self):
+        assert (gitinfo.normalize_remote_url("https://github.com/user/repo")
+                == "https://github.com/user/repo")
+
+    def test_https_strips_embedded_credentials(self):
+        assert (gitinfo.normalize_remote_url("https://token@github.com/user/repo.git")
+                == "https://github.com/user/repo")
+
+    def test_trailing_slash(self):
+        assert (gitinfo.normalize_remote_url("https://github.com/user/repo/")
+                == "https://github.com/user/repo")
+
+
+class TestSlugify:
+    def test_lowercases(self):
+        assert gitinfo.slugify("MyApp") == "myapp"
+
+    def test_spaces_and_underscores(self):
+        assert gitinfo.slugify("my cool_app") == "my-cool-app"
+
+    def test_collapses_separators(self):
+        assert gitinfo.slugify("my___app") == "my-app"
+
+    def test_trims_leading_trailing(self):
+        assert gitinfo.slugify("--app--") == "app"
+
+    def test_leading_non_alnum_gets_prefix(self):
+        assert gitinfo.slugify("_private")[0].isalnum()
+
+    def test_empty_falls_back(self):
+        assert gitinfo.slugify("!!!") == "app"
+
+    def test_min_length(self):
+        assert len(gitinfo.slugify("x")) >= 2
+
+    def test_valid_pattern(self):
+        import re
+        for name in ["My App!", "123-go", "___", "a", "Über-Service"]:
+            slug = gitinfo.slugify(name)
+            assert re.match(r"^[a-z0-9][a-z0-9-]*$", slug), slug
+
+
+class TestReadGitConfig:
+    def _write_repo(self, tmp_path, config_text, head_text="ref: refs/heads/main\n"):
+        git = tmp_path / ".git"
+        git.mkdir()
+        (git / "config").write_text(config_text)
+        (git / "HEAD").write_text(head_text)
+        return tmp_path
+
+    def test_reads_origin_with_tabs(self, tmp_path):
+        # git indents entries with tabs — the parser must handle that.
+        cfg = (
+            '[core]\n\trepositoryformatversion = 0\n'
+            '[remote "origin"]\n\turl = git@github.com:user/repo.git\n'
+            '\tfetch = +refs/heads/*:refs/remotes/origin/*\n'
+        )
+        root = self._write_repo(tmp_path, cfg)
+        assert gitinfo.read_origin_url(root) == "https://github.com/user/repo"
+
+    def test_prefers_origin_over_other_remote(self, tmp_path):
+        cfg = (
+            '[remote "upstream"]\n\turl = https://github.com/up/stream.git\n'
+            '[remote "origin"]\n\turl = https://github.com/me/mine.git\n'
+        )
+        root = self._write_repo(tmp_path, cfg)
+        assert gitinfo.read_origin_url(root) == "https://github.com/me/mine"
+
+    def test_falls_back_to_first_remote(self, tmp_path):
+        cfg = '[remote "fork"]\n\turl = https://github.com/x/y.git\n'
+        root = self._write_repo(tmp_path, cfg)
+        assert gitinfo.read_origin_url(root) == "https://github.com/x/y"
+
+    def test_no_remote_returns_none(self, tmp_path):
+        root = self._write_repo(tmp_path, "[core]\n\tbare = false\n")
+        assert gitinfo.read_origin_url(root) is None
+
+    def test_current_branch(self, tmp_path):
+        root = self._write_repo(tmp_path, "[core]\n", head_text="ref: refs/heads/feature/x\n")
+        assert gitinfo.read_current_branch(root) == "feature/x"
+
+    def test_detached_head_returns_none(self, tmp_path):
+        root = self._write_repo(tmp_path, "[core]\n", head_text="abc123def456\n")
+        assert gitinfo.read_current_branch(root) is None