jitly 0.1.0__py3-none-any.whl

jitly/__init__.py

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

jitly/commands/auth.py

@@ -0,0 +1,76 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+from jitly.core.jira_client import interactive_login, JiraClient
+from jitly.core.auth_store import save_credentials, load_credentials, delete_credentials
+from jitly.core.config import GlobalConfig
+from jitly.core import backend_client
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command("login")
+def login():
+    """Authenticate with Jira (SSO, API token, or PAT)."""
+    console.print("\n[bold cyan]Welcome to Jitly![/] Let's connect your Jira account.\n")
+
+    try:
+        creds = interactive_login()
+    except Exception as e:
+        console.print(f"[red]Login failed:[/] {e}")
+        raise typer.Exit(1)
+
+    client = JiraClient(creds)
+    try:
+        me = client.get_myself()
+    except Exception as e:
+        console.print(f"[red]Could not verify Jira credentials:[/] {e}")
+        raise typer.Exit(1)
+
+    display_name = me.get("displayName", "Unknown")
+    email = me.get("emailAddress", creds.get("email", ""))
+
+    save_credentials(creds)
+    console.print(f"\n[bold green]✓ Logged in as {display_name}[/] ({email})")
+
+    # Register/sync user with backend
+    try:
+        result = backend_client.register_user(creds, display_name, email)
+        token = result.get("token")
+        if token:
+            GlobalConfig().set("backend_token", token)
+        console.print("[dim]✓ Synced with Jitly backend[/]")
+    except Exception:
+        console.print("[dim yellow]⚠ Could not reach Jitly backend — working in offline mode[/]")
+
+
+@app.command("logout")
+def logout():
+    """Remove stored Jira credentials."""
+    delete_credentials()
+    GlobalConfig().delete("backend_token")
+    console.print("[green]✓ Logged out successfully[/]")
+
+
+@app.command("whoami")
+def whoami():
+    """Show current authenticated user."""
+    creds = load_credentials()
+    if not creds:
+        console.print("[yellow]Not logged in. Run:[/] jitly auth login")
+        raise typer.Exit(1)
+
+    client = JiraClient(creds)
+    try:
+        me = client.get_myself()
+    except Exception as e:
+        console.print(f"[red]Failed to fetch user info:[/] {e}")
+        raise typer.Exit(1)
+
+    table = Table(show_header=False, box=None)
+    table.add_row("[dim]Name[/]", me.get("displayName", "-"))
+    table.add_row("[dim]Email[/]", me.get("emailAddress", "-"))
+    table.add_row("[dim]Auth type[/]", creds.get("auth_type", "-"))
+    table.add_row("[dim]Site[/]", creds.get("site_url", creds.get("site_name", "-")))
+    console.print(table)

jitly/commands/done.py

@@ -0,0 +1,130 @@
+"""jitly done — commit, push, and wrap up the current ticket."""
+import typer
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+from typing import Optional
+from jitly.core.auth_store import load_credentials
+from jitly.core.jira_client import JiraClient
+from jitly.core.config import GlobalConfig, ProjectConfig
+from jitly.core.git_ops import (
+    get_repo, is_dirty, current_branch, add_and_commit, push_branch,
+)
+from jitly.core import backend_client
+
+console = Console()
+
+
+def _format_commit(template: str, ticket_id: str, desc: str, message: str) -> str:
+    return (
+        template
+        .replace("{ticket}", ticket_id)
+        .replace("{desc}", desc)
+        .replace("{message}", message)
+    )
+
+
+def done(
+    message: Optional[str] = typer.Option(None, "--message", "-m", help="Custom commit message"),
+    remote: str = typer.Option("origin", "--remote", "-r"),
+    no_push: bool = typer.Option(False, "--no-push", help="Commit only, don't push"),
+):
+    """Commit & push current work and mark the Jira ticket as done."""
+    creds = load_credentials()
+    if not creds:
+        console.print("[red]Not logged in. Run:[/] jitly auth login")
+        raise typer.Exit(1)
+
+    proj_cfg = ProjectConfig()
+    ticket_id = proj_cfg.get("active_ticket")
+    if not ticket_id:
+        console.print("[yellow]No active ticket. Did you run:[/] jitly start <TICKET>")
+        ticket_id = questionary.text("Enter ticket ID manually (or leave blank to skip):").ask()
+        if not ticket_id:
+            ticket_id = ""
+
+    policy = GlobalConfig().get("policy") or {}
+    commit_template = policy.get("commit_template", "{ticket}: {desc}")
+
+    # Fetch ticket summary for default commit message
+    summary = ""
+    if ticket_id and creds:
+        try:
+            client = JiraClient(creds)
+            issue = client.get_ticket(ticket_id)
+            summary = issue.get("fields", {}).get("summary", "")
+        except Exception:
+            pass
+
+    branch = current_branch(get_repo())
+    console.print(f"\n[bold]Branch:[/] {branch}")
+    if ticket_id:
+        console.print(f"[bold]Ticket:[/] {ticket_id} — {summary}")
+
+    repo = get_repo()
+    if not is_dirty(repo):
+        console.print("[yellow]Nothing to commit.[/]")
+        push_anyway = questionary.confirm("Push current branch anyway?", default=True).ask()
+        if push_anyway and not no_push:
+            push_branch(repo, branch, remote)
+            console.print(f"[green]✓ Pushed[/] {branch}")
+        raise typer.Exit(0)
+
+    # Build commit message
+    if message:
+        final_message = message
+    else:
+        default_msg = _format_commit(commit_template, ticket_id or "", summary, summary)
+        final_message = questionary.text(
+            "Commit message:",
+            default=default_msg,
+        ).ask()
+        if not final_message:
+            final_message = default_msg
+
+    # Show summary before committing
+    console.print(
+        Panel(
+            f"[bold]Message:[/] {final_message}\n[bold]Branch:[/] {branch}",
+            title="About to commit",
+            border_style="cyan",
+        )
+    )
+    confirmed = questionary.confirm("Proceed?", default=True).ask()
+    if not confirmed:
+        console.print("[yellow]Aborted.[/]")
+        raise typer.Exit(0)
+
+    add_and_commit(repo, final_message)
+    console.print(f"[green]✓ Committed[/]")
+
+    if not no_push:
+        with console.status(f"Pushing to {remote}/{branch}..."):
+            push_branch(repo, branch, remote)
+        console.print(f"[green]✓ Pushed[/] to {remote}/{branch}")
+
+    # Transition Jira ticket
+    if ticket_id:
+        done_status = questionary.select(
+            "Mark ticket as:",
+            choices=["Done", "In Review", "Ready for QA", "Keep current status"],
+        ).ask()
+        if done_status != "Keep current status":
+            try:
+                client = JiraClient(creds)
+                client.transition_ticket(ticket_id, done_status)
+                console.print(f"[dim]✓ Ticket moved to {done_status}[/]")
+            except Exception as e:
+                console.print(f"[yellow]⚠ Could not update Jira status: {e}[/]")
+
+    # Clear active ticket
+    proj_cfg.set("active_ticket", None)
+    proj_cfg.set("active_branch", None)
+
+    backend_client.track_event("ticket.done", {
+        "ticket_id": ticket_id,
+        "branch": branch,
+        "commit_message": final_message,
+    })
+
+    console.print(f"\n[bold green]All done![/] Great work on {ticket_id or branch}.")

jitly/commands/init.py

@@ -0,0 +1,64 @@
+"""jitly init — link current git repo to Jira project."""
+import typer
+import questionary
+from rich.console import Console
+from pathlib import Path
+from jitly.core.config import ProjectConfig
+from jitly.core.git_ops import get_repo, get_remote_url
+from jitly.core.auth_store import load_credentials
+from jitly.core.jira_client import JiraClient
+
+console = Console()
+
+
+def init():
+    """Link this git repository to a Jira project."""
+    creds = load_credentials()
+    if not creds:
+        console.print("[red]Not logged in. Run:[/] jitly auth login")
+        raise typer.Exit(1)
+
+    try:
+        repo = get_repo()
+    except Exception:
+        console.print("[red]Not inside a git repository.[/]")
+        raise typer.Exit(1)
+
+    cfg = ProjectConfig()
+    remote_url = get_remote_url(repo)
+    console.print(f"\n[bold]Setting up Jitly for this repository[/]")
+    if remote_url:
+        console.print(f"[dim]Remote:[/] {remote_url}")
+
+    # Fetch Jira projects the user has access to
+    client = JiraClient(creds)
+    try:
+        resp = __import__("httpx").get(
+            f"{client._base_url}/project/search",
+            headers=client._headers,
+            params={"maxResults": 50, "orderBy": "name"},
+        )
+        resp.raise_for_status()
+        projects = resp.json().get("values", [])
+        choices = [f"{p['key']} — {p['name']}" for p in projects]
+    except Exception:
+        choices = []
+
+    if choices:
+        selected = questionary.select("Select Jira project for this repo:", choices=choices).ask()
+        project_key = selected.split(" — ")[0]
+        project_name = selected.split(" — ")[1]
+    else:
+        project_key = questionary.text("Jira project key (e.g. ABC):").ask().upper()
+        project_name = project_key
+
+    cfg.set("project_key", project_key)
+    cfg.set("project_name", project_name)
+    if remote_url:
+        cfg.set("remote_url", remote_url)
+
+    console.print(f"\n[green]✓ Initialized![/] This repo is linked to Jira project [bold]{project_key}[/]")
+    console.print(f"[dim]Config saved to .jitly.yaml[/]")
+    console.print("\nNext steps:")
+    console.print("  [cyan]jitly policy setup[/]  — configure your workflow policies")
+    console.print("  [cyan]jitly start ABC-123[/]  — start working on a ticket")

jitly/commands/policy.py

@@ -0,0 +1,90 @@
+"""jitly policy — manage development workflow policies."""
+import typer
+import questionary
+from rich.console import Console
+from rich.table import Table
+from jitly.core.config import GlobalConfig
+from jitly.core import backend_client
+
+app = typer.Typer()
+console = Console()
+
+DEFAULT_BRANCH_TEMPLATE = "feature/{ticket_lower}-{desc}"
+
+
+def _load_policy() -> dict:
+    cfg = GlobalConfig()
+    return cfg.get("policy") or {}
+
+
+def _save_policy(policy: dict) -> None:
+    cfg = GlobalConfig()
+    cfg.set("policy", policy)
+    try:
+        backend_client.save_policy(policy)
+    except Exception:
+        pass
+
+
+@app.command("setup")
+def setup():
+    """Interactively configure your development policies."""
+    console.print("\n[bold cyan]Development Policy Setup[/]\n")
+    policy = _load_policy()
+
+    base_branch = questionary.text(
+        "Base branch to pull from before creating new branches:",
+        default=policy.get("base_branch", "main"),
+    ).ask()
+
+    branch_template = questionary.text(
+        "Branch name template (tokens: {ticket}, {ticket_lower}, {desc}):",
+        default=policy.get("branch_template", DEFAULT_BRANCH_TEMPLATE),
+    ).ask()
+
+    auto_pull = questionary.confirm(
+        "Auto-pull base branch before creating a new branch?",
+        default=policy.get("auto_pull", True),
+    ).ask()
+
+    commit_template = questionary.text(
+        "Commit message template (tokens: {ticket}, {desc}, {message}):",
+        default=policy.get("commit_template", "{ticket}: {desc}"),
+    ).ask()
+
+    policy = {
+        "base_branch": base_branch,
+        "branch_template": branch_template,
+        "auto_pull": auto_pull,
+        "commit_template": commit_template,
+    }
+    _save_policy(policy)
+    console.print("\n[green]✓ Policy saved![/]")
+
+
+@app.command("show")
+def show():
+    """Display current development policies."""
+    policy = _load_policy()
+    if not policy:
+        console.print("[yellow]No policy configured. Run:[/] jitly policy setup")
+        return
+
+    table = Table(title="Development Policy", show_header=False, box=None, padding=(0, 2))
+    for k, v in policy.items():
+        table.add_row(f"[dim]{k}[/]", str(v))
+    console.print(table)
+
+
+@app.command("set")
+def set_policy(
+    key: str = typer.Argument(..., help="Policy key"),
+    value: str = typer.Argument(..., help="Policy value"),
+):
+    """Set a single policy value."""
+    policy = _load_policy()
+    if value.lower() in ("true", "false"):
+        value = value.lower() == "true"
+    policy[key] = value
+    _save_policy(policy)
+    console.print(f"[green]✓[/] {key} = {value}")

jitly/commands/start.py

@@ -0,0 +1,153 @@
+"""jitly start <TICKET-ID> — begin work on a Jira ticket."""
+import typer
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+from typing import Optional
+from jitly.core.auth_store import load_credentials
+from jitly.core.jira_client import JiraClient
+from jitly.core.config import GlobalConfig, ProjectConfig
+from jitly.core.git_ops import (
+    get_repo, is_dirty, current_branch, branch_exists_local, branch_exists_remote,
+    checkout_branch, fetch_and_checkout_remote_branch, pull_base_branch,
+    format_branch_name, stash_changes, push_branch, add_and_commit,
+)
+from jitly.core import backend_client
+
+console = Console()
+
+
+def _get_policy() -> dict:
+    cfg = GlobalConfig()
+    policy = cfg.get("policy")
+    if not policy:
+        console.print("[yellow]No policy configured yet. Let's set it up first.[/]\n")
+        from jitly.commands.policy import setup
+        setup()
+        policy = cfg.get("policy") or {}
+    return policy
+
+
+def start(
+    ticket_id: str = typer.Argument(..., help="Jira ticket ID (e.g. ABC-123)"),
+    remote: str = typer.Option("origin", "--remote", "-r", help="Git remote name"),
+):
+    """Start working on a Jira ticket — creates/switches to the right branch."""
+    creds = load_credentials()
+    if not creds:
+        console.print("[red]Not logged in. Run:[/] jitly auth login")
+        raise typer.Exit(1)
+
+    ticket_id = ticket_id.upper()
+
+    # Fetch ticket info
+    client = JiraClient(creds)
+    with console.status(f"Fetching ticket [bold]{ticket_id}[/]..."):
+        try:
+            issue = client.get_ticket(ticket_id)
+        except Exception as e:
+            console.print(f"[red]Could not fetch ticket {ticket_id}:[/] {e}")
+            raise typer.Exit(1)
+
+    fields = issue.get("fields", {})
+    summary = fields.get("summary", "")
+    status = fields.get("status", {}).get("name", "")
+    issue_type = fields.get("issuetype", {}).get("name", "feature").lower()
+
+    console.print(
+        Panel(
+            f"[bold]{ticket_id}[/] — {summary}\n[dim]Status:[/] {status}  [dim]Type:[/] {issue_type}",
+            title="Jira Ticket",
+            border_style="cyan",
+        )
+    )
+
+    policy = _get_policy()
+    branch_name = format_branch_name(
+        policy["branch_template"], ticket_id, summary
+    ).replace("{type}", issue_type)
+
+    try:
+        repo = get_repo()
+    except Exception:
+        console.print("[red]Not inside a git repository. Run:[/] jitly init")
+        raise typer.Exit(1)
+
+    # Handle dirty working directory — always ask at runtime
+    if is_dirty(repo):
+        dirty_action = questionary.select(
+            f"You have uncommitted changes on [bold]{current_branch(repo)}[/]. What would you like to do?",
+            choices=[
+                "stash — save changes and continue to new ticket",
+                "push — commit & push current changes first",
+                "cancel — abort",
+            ],
+        ).ask()
+        if not dirty_action or "cancel" in dirty_action:
+            console.print("[yellow]Aborted.[/]")
+            raise typer.Exit(0)
+        dirty_action = dirty_action.split(" — ")[0]
+
+        if dirty_action == "stash":
+            stash_changes(repo, f"jitly: before switching to {ticket_id}")
+            console.print("[dim]✓ Changes stashed[/]")
+        elif dirty_action == "push":
+            current = current_branch(repo)
+            msg = questionary.text(
+                "Commit message:", default=f"WIP: saving before {ticket_id}"
+            ).ask()
+            add_and_commit(repo, msg)
+            push_branch(repo, current, remote)
+            console.print(f"[dim]✓ Changes committed and pushed to {current}[/]")
+
+    # Check if branch already exists remotely (someone else worked on this)
+    base_branch = policy["base_branch"]
+    already_existed_remote = branch_exists_remote(repo, branch_name, remote)
+    already_existed_local = branch_exists_local(repo, branch_name)
+
+    if already_existed_remote and not already_existed_local:
+        console.print(
+            f"\n[yellow]Branch [bold]{branch_name}[/] exists on remote.[/]\n"
+            "[dim]Someone may have already started this ticket. Fetching their work...[/]"
+        )
+        fetch_and_checkout_remote_branch(repo, branch_name, remote)
+        console.print(f"[green]✓ Checked out existing branch[/] [bold]{branch_name}[/]")
+
+    elif already_existed_local:
+        console.print(f"[dim]Branch exists locally, switching to[/] [bold]{branch_name}[/]")
+        checkout_branch(repo, branch_name)
+
+    else:
+        # Fresh branch: pull base first
+        if policy.get("auto_pull", True):
+            with console.status(f"Pulling latest [bold]{base_branch}[/]..."):
+                try:
+                    pull_base_branch(repo, base_branch, remote)
+                    console.print(f"[dim]✓ Pulled latest {base_branch}[/]")
+                except Exception as e:
+                    console.print(f"[yellow]⚠ Could not pull {base_branch}: {e}[/]")
+
+        checkout_branch(repo, branch_name, create=True)
+        console.print(f"[green]✓ Created and checked out[/] [bold]{branch_name}[/]")
+
+    # Store active ticket in project config
+    proj_cfg = ProjectConfig()
+    proj_cfg.set("active_ticket", ticket_id)
+    proj_cfg.set("active_branch", branch_name)
+
+    # Track in backend
+    backend_client.track_event("ticket.started", {
+        "ticket_id": ticket_id,
+        "branch": branch_name,
+        "summary": summary,
+    })
+
+    # Optionally transition ticket to "In Progress"
+    try:
+        client.transition_ticket(ticket_id, "In Progress")
+        console.print(f"[dim]✓ Ticket moved to In Progress[/]")
+    except Exception:
+        pass
+
+    console.print(f"\n[bold green]Ready![/] You're now on [bold]{branch_name}[/]")
+    console.print(f"[dim]When done, run:[/] jitly done")

jitly/commands/status.py

@@ -0,0 +1,45 @@
+"""jitly status — show current ticket and branch state."""
+import typer
+from rich.console import Console
+from rich.table import Table
+from jitly.core.config import ProjectConfig
+from jitly.core.git_ops import get_repo, current_branch, is_dirty
+from jitly.core.auth_store import load_credentials
+from jitly.core.jira_client import JiraClient
+
+console = Console()
+
+
+def status():
+    """Show current ticket, branch, and working directory status."""
+    proj_cfg = ProjectConfig()
+    ticket_id = proj_cfg.get("active_ticket")
+
+    try:
+        repo = get_repo()
+        branch = current_branch(repo)
+        dirty = is_dirty(repo)
+    except Exception:
+        branch = "—"
+        dirty = False
+
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_row("[dim]Branch[/]", branch)
+    table.add_row("[dim]Working tree[/]", "[yellow]dirty[/]" if dirty else "[green]clean[/]")
+
+    if ticket_id:
+        table.add_row("[dim]Active ticket[/]", ticket_id)
+        creds = load_credentials()
+        if creds:
+            try:
+                client = JiraClient(creds)
+                issue = client.get_ticket(ticket_id)
+                fields = issue.get("fields", {})
+                table.add_row("[dim]Summary[/]", fields.get("summary", "—"))
+                table.add_row("[dim]Jira status[/]", fields.get("status", {}).get("name", "—"))
+            except Exception:
+                pass
+    else:
+        table.add_row("[dim]Active ticket[/]", "[dim]none[/]")
+
+    console.print(table)

jitly/core/auth_store.py

@@ -0,0 +1,48 @@
+"""Secure credential storage using system keyring with YAML fallback."""
+import json
+from typing import Optional
+
+try:
+    import keyring
+    _KEYRING_AVAILABLE = True
+except Exception:
+    _KEYRING_AVAILABLE = False
+
+from jitly.core.config import GlobalConfig
+
+SERVICE_NAME = "jitly"
+CRED_KEY = "credentials"
+
+
+def save_credentials(creds: dict) -> None:
+    if _KEYRING_AVAILABLE:
+        try:
+            keyring.set_password(SERVICE_NAME, CRED_KEY, json.dumps(creds))
+            return
+        except Exception:
+            pass
+    # fallback: store in config (less secure but works everywhere)
+    cfg = GlobalConfig()
+    cfg.set("credentials", creds)
+
+
+def load_credentials() -> Optional[dict]:
+    if _KEYRING_AVAILABLE:
+        try:
+            val = keyring.get_password(SERVICE_NAME, CRED_KEY)
+            if val:
+                return json.loads(val)
+        except Exception:
+            pass
+    cfg = GlobalConfig()
+    return cfg.get("credentials")
+
+
+def delete_credentials() -> None:
+    if _KEYRING_AVAILABLE:
+        try:
+            keyring.delete_password(SERVICE_NAME, CRED_KEY)
+        except Exception:
+            pass
+    cfg = GlobalConfig()
+    cfg.delete("credentials")

jitly/core/backend_client.py

@@ -0,0 +1,59 @@
+"""HTTP client for Jitly backend API."""
+from typing import Optional
+import httpx
+from jitly.core.config import get_backend_url, GlobalConfig
+
+
+def _get_token() -> Optional[str]:
+    return GlobalConfig().get("backend_token")
+
+
+def _headers() -> dict:
+    token = _get_token()
+    return {"Authorization": f"Bearer {token}"} if token else {}
+
+
+def register_user(jira_creds: dict, display_name: str, email: str) -> dict:
+    resp = httpx.post(
+        f"{get_backend_url()}/api/users/register",
+        json={"jira_creds": jira_creds, "display_name": display_name, "email": email},
+        timeout=15,
+    )
+    resp.raise_for_status()
+    return resp.json()
+
+
+def track_event(event: str, payload: dict) -> None:
+    try:
+        httpx.post(
+            f"{get_backend_url()}/api/activity",
+            json={"event": event, "payload": payload},
+            headers=_headers(),
+            timeout=5,
+        )
+    except Exception:
+        pass  # activity tracking is non-blocking
+
+
+def save_policy(policy: dict) -> None:
+    resp = httpx.post(
+        f"{get_backend_url()}/api/policy",
+        json=policy,
+        headers=_headers(),
+        timeout=10,
+    )
+    resp.raise_for_status()
+
+
+def get_policy() -> Optional[dict]:
+    try:
+        resp = httpx.get(
+            f"{get_backend_url()}/api/policy",
+            headers=_headers(),
+            timeout=10,
+        )
+        if resp.status_code == 200:
+            return resp.json()
+    except Exception:
+        pass
+    return None

jitly/core/config.py

@@ -0,0 +1,71 @@
+"""Manages local config stored in ~/.jitly/config.yaml and per-project .jitly.yaml"""
+import os
+import yaml
+from pathlib import Path
+from typing import Any, Optional
+from platformdirs import user_config_dir
+
+GLOBAL_CONFIG_DIR = Path(user_config_dir("jitly"))
+GLOBAL_CONFIG_FILE = GLOBAL_CONFIG_DIR / "config.yaml"
+PROJECT_CONFIG_FILE = ".jitly.yaml"
+
+# BACKEND_URL_DEFAULT = "https://api.jitly.dev"  # override via JITLY_BACKEND_URL env
+BACKEND_URL_DEFAULT = "http://localhost:8000"
+
+
+def get_backend_url() -> str:
+    return os.environ.get("JITLY_BACKEND_URL", BACKEND_URL_DEFAULT)
+
+
+def _load_yaml(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    with open(path) as f:
+        return yaml.safe_load(f) or {}
+
+
+def _save_yaml(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        yaml.dump(data, f, default_flow_style=False)
+
+
+class GlobalConfig:
+    def __init__(self):
+        self._data = _load_yaml(GLOBAL_CONFIG_FILE)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._data[key] = value
+        _save_yaml(GLOBAL_CONFIG_FILE, self._data)
+
+    def delete(self, key: str) -> None:
+        self._data.pop(key, None)
+        _save_yaml(GLOBAL_CONFIG_FILE, self._data)
+
+    @property
+    def all(self) -> dict:
+        return self._data
+
+
+class ProjectConfig:
+    def __init__(self, path: Optional[Path] = None):
+        self._path = Path(path or Path.cwd()) / PROJECT_CONFIG_FILE
+        self._data = _load_yaml(self._path)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        self._data[key] = value
+        _save_yaml(self._path, self._data)
+
+    @property
+    def exists(self) -> bool:
+        return self._path.exists()
+
+    @property
+    def all(self) -> dict:
+        return self._data

jitly/core/git_ops.py

@@ -0,0 +1,93 @@
+"""Git operations wrapper using GitPython."""
+import re
+from pathlib import Path
+from typing import Optional
+import git
+from rich.console import Console
+
+console = Console()
+
+
+def get_repo(path: Optional[Path] = None) -> git.Repo:
+    return git.Repo(path or Path.cwd(), search_parent_directories=True)
+
+
+def is_dirty(repo: git.Repo) -> bool:
+    return repo.is_dirty(untracked_files=True)
+
+
+def current_branch(repo: git.Repo) -> str:
+    return repo.active_branch.name
+
+
+def branch_exists_local(repo: git.Repo, branch: str) -> bool:
+    return branch in [b.name for b in repo.branches]
+
+
+def branch_exists_remote(repo: git.Repo, branch: str, remote: str = "origin") -> bool:
+    try:
+        remote_obj = repo.remote(remote)
+        remote_obj.fetch()
+        return any(ref.name == f"{remote}/{branch}" for ref in remote_obj.refs)
+    except Exception:
+        return False
+
+
+def checkout_branch(repo: git.Repo, branch: str, create: bool = False) -> None:
+    if create:
+        repo.git.checkout("-b", branch)
+    else:
+        repo.git.checkout(branch)
+
+
+def pull_base_branch(repo: git.Repo, base_branch: str, remote: str = "origin") -> None:
+    current = current_branch(repo)
+    repo.git.checkout(base_branch)
+    repo.git.pull(remote, base_branch)
+    repo.git.checkout(current)
+
+
+def fetch_and_checkout_remote_branch(repo: git.Repo, branch: str, remote: str = "origin") -> None:
+    repo.git.fetch(remote, branch)
+    repo.git.checkout("-b", branch, f"{remote}/{branch}")
+
+
+def stash_changes(repo: git.Repo, message: str = "jitly: auto-stash") -> None:
+    repo.git.stash("push", "-m", message)
+
+
+def pop_stash(repo: git.Repo) -> None:
+    repo.git.stash("pop")
+
+
+def push_branch(repo: git.Repo, branch: str, remote: str = "origin") -> None:
+    repo.git.push("--set-upstream", remote, branch)
+
+
+def add_and_commit(repo: git.Repo, message: str) -> None:
+    repo.git.add("-A")
+    repo.index.commit(message)
+
+
+def get_remote_url(repo: git.Repo, remote: str = "origin") -> Optional[str]:
+    try:
+        return repo.remote(remote).url
+    except Exception:
+        return None
+
+
+def format_branch_name(template: str, ticket_id: str, description: str = "") -> str:
+    """
+    Template tokens:
+      {ticket}      → ticket ID (e.g. ABC-123)
+      {ticket_lower}→ lowercase ticket ID
+      {desc}        → slugified ticket description
+      {type}        → issue type (feature/bug/etc) — passed explicitly
+    """
+    slug = re.sub(r"[^a-z0-9]+", "-", description.lower()).strip("-")[:40]
+    return (
+        template
+        .replace("{ticket}", ticket_id)
+        .replace("{ticket_lower}", ticket_id.lower())
+        .replace("{desc}", slug)
+    )

jitly/core/jira_client.py

@@ -0,0 +1,276 @@
+"""Jira API client supporting cloud (OAuth2/API token) and server (PAT)."""
+import os
+import webbrowser
+import http.server
+import threading
+import urllib.parse
+import secrets
+import base64
+from typing import Optional
+import httpx
+from rich.console import Console
+from rich.prompt import Prompt
+import questionary
+from dotenv import load_dotenv
+
+load_dotenv()
+
+console = Console()
+
+JIRA_CLOUD_AUTH_URL = "https://auth.atlassian.com/authorize"
+JIRA_CLOUD_TOKEN_URL = "https://auth.atlassian.com/oauth/token"
+JIRA_CLOUD_RESOURCES_URL = "https://api.atlassian.com/oauth/token/accessible-resources"
+
+OAUTH_CLIENT_ID = os.environ.get("JITLY_OAUTH_CLIENT_ID", "")
+OAUTH_CLIENT_SECRET = os.environ.get("JITLY_OAUTH_CLIENT_SECRET", "")
+OAUTH_REDIRECT_PORT = int(os.environ.get("JITLY_OAUTH_PORT", "8727"))
+OAUTH_REDIRECT_URI = f"http://localhost:{OAUTH_REDIRECT_PORT}/callback"
+OAUTH_SCOPES = "read:me read:jira-work write:jira-work offline_access"
+
+
+class OAuthCallbackHandler(http.server.BaseHTTPRequestHandler):
+    code: Optional[str] = None
+    state: Optional[str] = None
+
+    def do_GET(self):
+        parsed = urllib.parse.urlparse(self.path)
+        params = urllib.parse.parse_qs(parsed.query)
+        OAuthCallbackHandler.code = params.get("code", [None])[0]
+        OAuthCallbackHandler.state = params.get("state", [None])[0]
+        self.send_response(200)
+        self.send_header("Content-type", "text/html")
+        self.end_headers()
+        self.wfile.write(b"<h2>Jitly: Authentication successful! You can close this tab.</h2>")
+
+    def log_message(self, *args):
+        pass  # suppress server logs
+
+
+def _oauth2_login() -> dict:
+    """Atlassian OAuth2 3LO flow — opens browser, captures callback."""
+    if not OAUTH_CLIENT_ID or not OAUTH_CLIENT_SECRET:
+        raise RuntimeError(
+            "OAuth2 credentials not set.\n"
+            "Add JITLY_OAUTH_CLIENT_ID and JITLY_OAUTH_CLIENT_SECRET to your .env file."
+        )
+    state = secrets.token_urlsafe(16)
+    params = {
+        "audience": "api.atlassian.com",
+        "client_id": OAUTH_CLIENT_ID,
+        "scope": OAUTH_SCOPES,
+        "redirect_uri": OAUTH_REDIRECT_URI,
+        "state": state,
+        "response_type": "code",
+        "prompt": "consent",
+    }
+    url = f"{JIRA_CLOUD_AUTH_URL}?{urllib.parse.urlencode(params)}"
+
+    OAuthCallbackHandler.code = None
+    server = http.server.HTTPServer(("localhost", OAUTH_REDIRECT_PORT), OAuthCallbackHandler)
+    thread = threading.Thread(target=server.handle_request)
+    thread.daemon = True
+    thread.start()
+
+    console.print(f"\n[bold cyan]Opening browser for Jira SSO login...[/]")
+    console.print(f"If browser doesn't open, visit:\n[link]{url}[/link]\n")
+    webbrowser.open(url)
+    thread.join(timeout=120)
+    server.server_close()
+
+    code = OAuthCallbackHandler.code
+    if not code:
+        raise RuntimeError("OAuth2 login timed out or was cancelled.")
+
+    # Exchange code for tokens
+    resp = httpx.post(
+        JIRA_CLOUD_TOKEN_URL,
+        json={
+            "grant_type": "authorization_code",
+            "client_id": OAUTH_CLIENT_ID,
+            "client_secret": OAUTH_CLIENT_SECRET,
+            "code": code,
+            "redirect_uri": OAUTH_REDIRECT_URI,
+        },
+    )
+    resp.raise_for_status()
+    tokens = resp.json()
+
+    # Fetch accessible Jira sites
+    sites_resp = httpx.get(
+        JIRA_CLOUD_RESOURCES_URL,
+        headers={"Authorization": f"Bearer {tokens['access_token']}"},
+    )
+    sites_resp.raise_for_status()
+    sites = sites_resp.json()
+
+    site = sites[0] if len(sites) == 1 else _pick_site(sites)
+
+    return {
+        "auth_type": "oauth2",
+        "access_token": tokens["access_token"],
+        "refresh_token": tokens.get("refresh_token"),
+        "cloud_id": site["id"],
+        "site_url": site["url"],
+        "site_name": site["name"],
+    }
+
+
+def _pick_site(sites: list) -> dict:
+    choices = [s["name"] for s in sites]
+    name = questionary.select("Select your Jira site:", choices=choices).ask()
+    return next(s for s in sites if s["name"] == name)
+
+
+def _api_token_login() -> dict:
+    """Classic Jira Cloud: email + API token."""
+    console.print("\n[bold]Generate an API token at:[/] https://id.atlassian.com/manage-profile/security/api-tokens")
+    site_url = Prompt.ask("Jira site URL (e.g. https://yourcompany.atlassian.net)").rstrip("/")
+    email = Prompt.ask("Atlassian email")
+    token = Prompt.ask("API token", password=True)
+
+    creds_b64 = base64.b64encode(f"{email}:{token}".encode()).decode()
+    resp = httpx.get(
+        f"{site_url}/rest/api/3/myself",
+        headers={"Authorization": f"Basic {creds_b64}", "Accept": "application/json"},
+    )
+    resp.raise_for_status()
+    me = resp.json()
+
+    return {
+        "auth_type": "api_token",
+        "site_url": site_url,
+        "email": email,
+        "api_token": token,
+        "account_id": me["accountId"],
+        "display_name": me.get("displayName", email),
+    }
+
+
+def _pat_login() -> dict:
+    """Jira Server / Data Center: PAT or username+password."""
+    site_url = Prompt.ask("Jira Server URL (e.g. https://jira.mycompany.com)").rstrip("/")
+    method = questionary.select(
+        "Auth method for Jira Server:",
+        choices=["Personal Access Token (PAT)", "Username + Password"],
+    ).ask()
+
+    if method == "Personal Access Token (PAT)":
+        pat = Prompt.ask("PAT", password=True)
+        headers = {"Authorization": f"Bearer {pat}", "Accept": "application/json"}
+    else:
+        username = Prompt.ask("Username")
+        password = Prompt.ask("Password", password=True)
+        creds_b64 = base64.b64encode(f"{username}:{password}".encode()).decode()
+        headers = {"Authorization": f"Basic {creds_b64}", "Accept": "application/json"}
+
+    resp = httpx.get(f"{site_url}/rest/api/2/myself", headers=headers)
+    resp.raise_for_status()
+    me = resp.json()
+
+    return {
+        "auth_type": "pat" if "PAT" in method else "basic",
+        "site_url": site_url,
+        "pat": pat if "PAT" in method else None,
+        "username": me.get("name") or me.get("displayName"),
+        "account_id": me.get("accountId") or me.get("key"),
+        "display_name": me.get("displayName"),
+        **({"api_token": password} if "Password" in method else {}),
+    }
+
+
+def interactive_login() -> dict:
+    """Prompt user to choose auth method then perform login."""
+    method = questionary.select(
+        "How would you like to login to Jira?",
+        choices=[
+            "SSO / OAuth2 (browser-based) — Jira Cloud",
+            "API Token — Jira Cloud",
+            "Personal Access Token / Password — Jira Server or Data Center",
+        ],
+    ).ask()
+
+    if not method:
+        raise SystemExit("Login cancelled.")
+
+    if "SSO" in method:
+        return _oauth2_login()
+    elif "API Token" in method:
+        return _api_token_login()
+    else:
+        return _pat_login()
+
+
+class JiraClient:
+    def __init__(self, creds: dict):
+        self.creds = creds
+        self._base_url = self._resolve_base_url()
+        self._headers = self._resolve_headers()
+
+    def _resolve_base_url(self) -> str:
+        auth_type = self.creds["auth_type"]
+        if auth_type == "oauth2":
+            return f"https://api.atlassian.com/ex/jira/{self.creds['cloud_id']}/rest/api/3"
+        return f"{self.creds['site_url']}/rest/api/3"
+
+    def _resolve_headers(self) -> dict:
+        auth_type = self.creds["auth_type"]
+        if auth_type == "oauth2":
+            return {
+                "Authorization": f"Bearer {self.creds['access_token']}",
+                "Accept": "application/json",
+            }
+        elif auth_type == "api_token":
+            creds_b64 = base64.b64encode(
+                f"{self.creds['email']}:{self.creds['api_token']}".encode()
+            ).decode()
+            return {"Authorization": f"Basic {creds_b64}", "Accept": "application/json"}
+        else:  # pat or basic
+            if self.creds.get("pat"):
+                return {"Authorization": f"Bearer {self.creds['pat']}", "Accept": "application/json"}
+            creds_b64 = base64.b64encode(
+                f"{self.creds['username']}:{self.creds['api_token']}".encode()
+            ).decode()
+            return {"Authorization": f"Basic {creds_b64}", "Accept": "application/json"}
+
+    def get_ticket(self, ticket_id: str) -> dict:
+        resp = httpx.get(
+            f"{self._base_url}/issue/{ticket_id}",
+            headers=self._headers,
+            params={"fields": "summary,status,assignee,issuetype,project"},
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_myself(self) -> dict:
+        # OAuth2 tokens use the Atlassian identity endpoint for user info
+        if self.creds.get("auth_type") == "oauth2":
+            resp = httpx.get(
+                "https://api.atlassian.com/me",
+                headers=self._headers,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            # Normalize to same shape as Jira /myself response
+            return {
+                "accountId": data.get("account_id"),
+                "displayName": data.get("name"),
+                "emailAddress": data.get("email"),
+            }
+        resp = httpx.get(f"{self._base_url}/myself", headers=self._headers)
+        resp.raise_for_status()
+        return resp.json()
+
+    def transition_ticket(self, ticket_id: str, status_name: str) -> None:
+        transitions_resp = httpx.get(
+            f"{self._base_url}/issue/{ticket_id}/transitions",
+            headers=self._headers,
+        )
+        transitions_resp.raise_for_status()
+        transitions = transitions_resp.json()["transitions"]
+        match = next((t for t in transitions if t["name"].lower() == status_name.lower()), None)
+        if match:
+            httpx.post(
+                f"{self._base_url}/issue/{ticket_id}/transitions",
+                headers={**self._headers, "Content-Type": "application/json"},
+                json={"transition": {"id": match["id"]}},
+            )

jitly/main.py

@@ -0,0 +1,27 @@
+import typer
+from rich.console import Console
+from jitly.commands import auth, init, start, done, policy, status
+
+app = typer.Typer(
+    name="jitly",
+    help="Bridge between Jira tickets and your local development workflow.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+console = Console()
+
+app.add_typer(auth.app, name="auth", help="Manage Jira authentication")
+app.add_typer(policy.app, name="policy", help="Manage development policies")
+
+app.command()(init.init)
+app.command()(start.start)
+app.command()(done.done)
+app.command()(status.status)
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

jitly-0.1.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: jitly
+Version: 0.1.0
+Summary: Bridge between Jira tickets and your local development workflow
+Author: Jitly
+License: MIT
+Keywords: jira,git,developer-tools,workflow
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer[all]>=0.12.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: gitpython>=3.1.40
+Requires-Dist: keyring>=25.0.0
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: requests>=2.31.0
+Requires-Dist: requests-oauthlib>=1.3.1
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: questionary>=2.0.1
+Requires-Dist: platformdirs>=4.2.0

jitly-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+jitly/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+jitly/main.py,sha256=psx3Ts7xAB2pkKM_t5DozvRC1r8TTRXifGfATblfRf4,626
+jitly/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jitly/commands/auth.py,sha256=D2qBHCsILHbs2Nm-aVCT1xsdcxkyhrjlw_hfbwSZtYM,2519
+jitly/commands/done.py,sha256=70nBjlydKoObDb1Tsi-qXO9v9qNP685AM0VPIl_msJU,4523
+jitly/commands/init.py,sha256=uoVDUocMe4aWuIVcCNaUGrWP6_g-CafWtiFZe7NCEdE,2282
+jitly/commands/policy.py,sha256=ZCwsQ6B5mjlCmRYATErfZCLO5cg05VaIcxmZ8MT0xLQ,2601
+jitly/commands/start.py,sha256=_R_eTZSv6nLuwSADNw_E8A8FUC_rwcmHopE3c9V6-5w,5859
+jitly/commands/status.py,sha256=YGFYgJVTfqj7DOztH_Qj8yyyFex1Pg0hvay5HAKAexE,1519
+jitly/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jitly/core/auth_store.py,sha256=uSoGW5KZ_z4gJLUVVv9Kdgt8aNqKQTdMEVRrm0_-ZSw,1201
+jitly/core/backend_client.py,sha256=YcfX3gK7h82XXIgYOlWhJ7iI7asIhSasnC7MzpwZxsA,1496
+jitly/core/config.py,sha256=pIOv11qZyOOrXJhRU4oFjUYmT0GnjTVSJRlPkd8CyAQ,2005
+jitly/core/git_ops.py,sha256=cYYyzrwOxPa_fQoXQ3A5C05JFnRs117OVrL7g9UV6xY,2669
+jitly/core/jira_client.py,sha256=FGhfR-xILCwaZy111LABJpfdko52QAR_jLwFr28nI9k,10017
+jitly/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jitly-0.1.0.dist-info/METADATA,sha256=_gJW-s_OqiL-huyss0VEC_l_DfIQHbyDuQelW5tCuu0,924
+jitly-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+jitly-0.1.0.dist-info/entry_points.txt,sha256=AIEOvvr-_kCmH2uO-Ky4PzP19HqHqBdceO-KzxY1gmU,41
+jitly-0.1.0.dist-info/top_level.txt,sha256=O1xlfgTU33pTqIIazAFZ-Pe97aVgpolWjnBw4h1xjWE,6
+jitly-0.1.0.dist-info/RECORD,,

jitly-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jitly-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jitly = jitly.main:app

jitly-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+jitly