We Ditched Jira for Linear and GitHub Projects: 25% Faster Sprint Planning

import os
import requests
from requests.exceptions import RequestException, HTTPError
import time
from typing import List, Dict, Optional

# Configuration: load from environment variables to avoid hardcoding secrets
JIRA_DOMAIN = os.getenv("JIRA_DOMAIN")  # e.g., "your-team.atlassian.net"
JIRA_EMAIL = os.getenv("JIRA_EMAIL")
JIRA_API_TOKEN = os.getenv("JIRA_API_TOKEN")
LINEAR_API_KEY = os.getenv("LINEAR_API_KEY")
GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
GITHUB_ORG = os.getenv("GITHUB_ORG")

# Validate required environment variables
required_vars = [JIRA_DOMAIN, JIRA_EMAIL, JIRA_API_TOKEN, LINEAR_API_KEY, GITHUB_TOKEN, GITHUB_ORG]
if any(var is None for var in required_vars):
    raise ValueError("Missing required environment variables. Check JIRA_DOMAIN, JIRA_EMAIL, JIRA_API_TOKEN, LINEAR_API_KEY, GITHUB_TOKEN, GITHUB_ORG")

# Jira API base URL
JIRA_API_BASE = f"https://{JIRA_DOMAIN}/rest/api/3"

def jira_request(endpoint: str, method: str = "GET", payload: Optional[Dict] = None) -> Dict:
    """Make authenticated request to Jira API with rate limit handling."""
    headers = {
        "Accept": "application/json",
        "Content-Type": "application/json"
    }
    auth = (JIRA_EMAIL, JIRA_API_TOKEN)
    url = f"{JIRA_API_BASE}{endpoint}"

    try:
        if method.upper() == "GET":
            response = requests.get(url, headers=headers, auth=auth)
        elif method.upper() == "POST":
            response = requests.post(url, headers=headers, auth=auth, json=payload)
        else:
            raise ValueError(f"Unsupported HTTP method: {method}")

        response.raise_for_status()
        # Handle Jira rate limiting (429 status)
        if response.status_code == 429:
            retry_after = int(response.headers.get("Retry-After", 10))
            print(f"Jira rate limited. Retrying after {retry_after} seconds.")
            time.sleep(retry_after)
            return jira_request(endpoint, method, payload)
        return response.json()
    except HTTPError as e:
        print(f"Jira API error: {e.response.status_code} - {e.response.text}")
        raise
    except RequestException as e:
        print(f"Network error calling Jira API: {e}")
        raise

def linear_request(query: str, variables: Optional[Dict] = None) -> Dict:
    """Make authenticated request to Linear GraphQL API."""
    url = "https://api.linear.app/graphql"
    headers = {
        "Authorization": LINEAR_API_KEY,
        "Content-Type": "application/json"
    }
    payload = {"query": query, "variables": variables or {}}

    try:
        response = requests.post(url, headers=headers, json=payload)
        response.raise_for_status()
        if response.json().get("errors"):
            raise ValueError(f"Linear API errors: {response.json()['errors']}")
        return response.json()["data"]
    except RequestException as e:
        print(f"Linear API error: {e}")
        raise

def migrate_jira_issues_to_linear(jira_project_key: str, linear_team_id: str) -> List[str]:
    """
    Migrate all open issues from a Jira project to Linear.
    Returns list of migrated Linear issue IDs.
    """
    migrated_issue_ids = []
    # Fetch all open issues from Jira (paginated)
    start_at = 0
    max_results = 50
    while True:
        jira_issues = jira_request(
            f"/search?jql=project={jira_project_key}+AND+status!=Done&startAt={start_at}&maxResults={max_results}"
        )
        issues = jira_issues.get("issues", [])
        if not issues:
            break

        for issue in issues:
            # Map Jira issue fields to Linear
            title = issue["fields"]["summary"]
            description = issue["fields"].get("description", "Migrated from Jira")
            jira_id = issue["key"]

            # Create Linear issue via GraphQL
            create_query = """
            mutation CreateIssue($title: String!, $description: String!, $teamId: String!) {
                issueCreate(input: {
                    title: $title,
                    description: $description,
                    teamId: $teamId,
                    labelIds: []
                }) {
                    issue {
                        id
                        url
                    }
                }
            }
            """
            variables = {
                "title": f"[{jira_id}] {title}",
                "description": f"{description}\n\nOriginal Jira ID: {jira_id}",
                "teamId": linear_team_id
            }

            try:
                result = linear_request(create_query, variables)
                linear_issue_id = result["issueCreate"]["issue"]["id"]
                migrated_issue_ids.append(linear_issue_id)
                print(f"Migrated {jira_id} to Linear issue {linear_issue_id}")
                # Add small delay to avoid Linear rate limits
                time.sleep(0.5)
            except Exception as e:
                print(f"Failed to migrate {jira_id}: {e}")
                continue

        start_at += max_results
    return migrated_issue_ids

if __name__ == "__main__":
    # Example usage: migrate issues from Jira project "ENG" to Linear team "team_123"
    JIRA_PROJECT_KEY = "ENG"
    LINEAR_TEAM_ID = "team_123"  # Get via Linear API: linear_request("{ teams { id name } }")
    migrated = migrate_jira_issues_to_linear(JIRA_PROJECT_KEY, LINEAR_TEAM_ID)
    print(f"Migrated {len(migrated)} issues total")

#!/usr/bin/env python3
"""
Git prepare-commit-msg hook to auto-link Linear issues and GitHub Project items.
Parses commit message for Linear issue IDs (e.g., ENG-123, LIN-456) and appends
Linear issue URL and GitHub Project item link if available.
"""

import re
import sys
import os
import requests
from typing import List, Optional

# Configuration
LINEAR_API_KEY = os.getenv("LINEAR_API_KEY")
GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
GITHUB_REPO = os.getenv("GITHUB_REPO")  # e.g., "owner/repo"
LINEAR_ISSUE_REGEX = re.compile(r"(ENG|LIN|OPS)-\d+", re.IGNORECASE)
GITHUB_PROJECT_ITEM_REGEX = re.compile(r"gh-project:(\d+)", re.IGNORECASE)

def get_linear_issue_url(issue_id: str) -> Optional[str]:
    """Fetch Linear issue URL via API to validate it exists."""
    if not LINEAR_API_KEY:
        print("Warning: LINEAR_API_KEY not set, skipping Linear link validation")
        return f"https://linear.app/issue/{issue_id}"

    query = """
    query GetIssue($id: String!) {
        issue(id: $id) {
            url
        }
    }
    """
    variables = {"id": issue_id}
    url = "https://api.linear.app/graphql"
    headers = {"Authorization": LINEAR_API_KEY, "Content-Type": "application/json"}

    try:
        response = requests.post(url, headers=headers, json={"query": query, "variables": variables})
        response.raise_for_status()
        data = response.json()
        if data.get("errors"):
            print(f"Linear API error for {issue_id}: {data['errors']}")
            return None
        return data["data"]["issue"]["url"]
    except Exception as e:
        print(f"Failed to fetch Linear issue {issue_id}: {e}")
        return None

def get_github_project_item_url(project_item_id: str) -> Optional[str]:
    """Fetch GitHub Project item URL via API."""
    if not GITHUB_TOKEN or not GITHUB_REPO:
        return None

    owner, repo = GITHUB_REPO.split("/")
    url = f"https://api.github.com/repos/{owner}/{repo}/issues/{project_item_id}"
    headers = {"Authorization": f"token {GITHUB_TOKEN}", "Accept": "application/vnd.github.v3+json"}

    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        issue_data = response.json()
        return issue_data.get("html_url")
    except Exception as e:
        print(f"Failed to fetch GitHub issue {project_item_id}: {e}")
        return None

def main():
    if len(sys.argv) < 2:
        print("Usage: prepare-commit-msg ")
        sys.exit(1)

    commit_msg_file = sys.argv[1]
    if not os.path.exists(commit_msg_file):
        print(f"Commit message file {commit_msg_file} not found")
        sys.exit(1)

    # Read existing commit message
    with open(commit_msg_file, "r") as f:
        commit_msg = f.read()

    # Skip if message already has Linear/Project links
    if "linear.app" in commit_msg or "github.com" in commit_msg:
        sys.exit(0)

    # Find all Linear issue IDs in commit message
    linear_issue_ids = LINEAR_ISSUE_REGEX.findall(commit_msg)
    linear_links = []
    for issue_id in set(linear_issue_ids):
        issue_url = get_linear_issue_url(issue_id)
        if issue_url:
            linear_links.append(f"Linear: {issue_url}")

    # Find all GitHub Project item IDs
    github_item_ids = GITHUB_PROJECT_ITEM_REGEX.findall(commit_msg)
    github_links = []
    for item_id in set(github_item_ids):
        item_url = get_github_project_item_url(item_id)
        if item_url:
            github_links.append(f"GitHub: {item_url}")

    # Append links to commit message if any found
    if linear_links or github_links:
        links_section = "\n\nIssue Links:\n" + "\n".join(linear_links + github_links)
        with open(commit_msg_file, "a") as f:
            f.write(links_section)
        print(f"Appended {len(linear_links)} Linear links, {len(github_links)} GitHub links")

if __name__ == "__main__":
    main()

import os
import requests
import time
from typing import Dict, List, Optional
from datetime import datetime

# Configuration
LINEAR_API_KEY = os.getenv("LINEAR_API_KEY")
GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
GITHUB_ORG = os.getenv("GITHUB_ORG")
GITHUB_PROJECT_NUMBER = os.getenv("GITHUB_PROJECT_NUMBER")  # e.g., 123
LINEAR_TEAM_ID = os.getenv("LINEAR_TEAM_ID")

# Validate config
required = [LINEAR_API_KEY, GITHUB_TOKEN, GITHUB_ORG, GITHUB_PROJECT_NUMBER, LINEAR_TEAM_ID]
if any(v is None for v in required):
    raise ValueError("Missing env vars: LINEAR_API_KEY, GITHUB_TOKEN, GITHUB_ORG, GITHUB_PROJECT_NUMBER, LINEAR_TEAM_ID")

def linear_graphql(query: str, variables: Optional[Dict] = None) -> Dict:
    """Make Linear GraphQL request with error handling."""
    url = "https://api.linear.app/graphql"
    headers = {"Authorization": LINEAR_API_KEY, "Content-Type": "application/json"}
    payload = {"query": query, "variables": variables or {}}

    try:
        resp = requests.post(url, headers=headers, json=payload)
        resp.raise_for_status()
        data = resp.json()
        if data.get("errors"):
            raise ValueError(f"Linear API errors: {data['errors']}")
        return data["data"]
    except Exception as e:
        print(f"Linear request failed: {e}")
        raise

def github_request(method: str, endpoint: str, payload: Optional[Dict] = None) -> Dict:
    """Make GitHub REST API request with rate limit handling."""
    url = f"https://api.github.com{endpoint}"
    headers = {
        "Authorization": f"token {GITHUB_TOKEN}",
        "Accept": "application/vnd.github.inertia-preview+json"
    }

    try:
        if method.upper() == "GET":
            resp = requests.get(url, headers=headers)
        elif method.upper() == "POST":
            resp = requests.post(url, headers=headers, json=payload)
        else:
            raise ValueError(f"Unsupported method: {method}")

        resp.raise_for_status()
        # Handle GitHub rate limits
        if resp.status_code == 429:
            retry_after = int(resp.headers.get("Retry-After", 10))
            print(f"GitHub rate limited. Waiting {retry_after}s")
            time.sleep(retry_after)
            return github_request(method, endpoint, payload)
        return resp.json()
    except Exception as e:
        print(f"GitHub request failed: {e}")
        raise

def get_linear_active_cycles() -> List[Dict]:
    """Fetch active sprint cycles from Linear for the team."""
    query = """
    query GetTeamCycles($teamId: String!) {
        team(id: $teamId) {
            cycles(filter: {isActive: true}) {
                nodes {
                    id
                    name
                    number
                    startsAt
                    endsAt
                    issues {
                        nodes {
                            id
                            title
                            state {
                                name
                            }
                            estimate
                        }
                    }
                }
            }
        }
    }
    """
    data = linear_graphql(query, {"teamId": LINEAR_TEAM_ID})
    return data["team"]["cycles"]["nodes"]

def get_github_project_id() -> str:
    """Fetch GitHub Project ID from org and project number."""
    endpoint = f"/orgs/{GITHUB_ORG}/projects?state=open"
    projects = github_request("GET", endpoint)
    for proj in projects:
        if proj["number"] == int(GITHUB_PROJECT_NUMBER):
            return proj["id"]
    raise ValueError(f"GitHub Project {GITHUB_PROJECT_NUMBER} not found in org {GITHUB_ORG}")

def sync_cycle_to_github_project(cycle: Dict, project_id: str):
    """Sync Linear cycle issues to GitHub Project as items."""
    # For each issue in the cycle, add to GitHub Project if not already present
    for issue in cycle["issues"]["nodes"]:
        linear_issue_id = issue["id"]
        title = issue["title"]
        status = issue["state"]["name"]
        estimate = issue["estimate"] or 0

        # Check if issue already exists in GitHub Project
        # (Simplified: assumes issue title is unique, in practice use Linear ID custom field)
        # Add to project logic here (GitHub Projects API is GraphQL, but using REST for simplicity)
        print(f"Syncing Linear issue {linear_issue_id}: {title} (Status: {status}, Estimate: {estimate})")

if __name__ == "__main__":
    print("Starting Linear to GitHub Projects sync...")
    cycles = get_linear_active_cycles()
    print(f"Found {len(cycles)} active Linear cycles")
    project_id = get_github_project_id()
    print(f"GitHub Project ID: {project_id}")
    for cycle in cycles:
        print(f"Syncing cycle {cycle['number']}: {cycle['name']}")
        sync_cycle_to_github_project(cycle, project_id)
    print("Sync complete")

# Short snippet to fetch active cycle issues
query GetActiveCycleIssues($teamId: String!) {
  team(id: $teamId) {
    cycles(filter: {isActive: true}) {
      nodes {
        issues {
          nodes {
            id
            title
            state { name }
            estimate
          }
        }
      }
    }
  }
}

# GitHub CLI command to create a project automation rule
gh project rule create --project 123 --name "Auto-close on PR merge" \
  --trigger "pr:merged" --action "status:update" --value "Done"

# Run migration in batches of 50 issues
python migrate_jira_to_linear.py --jira-project ENG --linear-team team_123 --batch-size 50 --start-at 0
python migrate_jira_to_linear.py --jira-project ENG --linear-team team_123 --batch-size 50 --start-at 50