We Ditched Linear 1.5 for Jira 2026 and Improved Our 2026 Team Sprint Velocity by 22%

import os
import time
import logging
from linear_api import LinearClient
from jira import Jira, IssueType, Project
from tenacity import retry, stop_after_attempt, wait_exponential

# Configure logging for audit trail
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("linear_jira_migration.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

# Load environment variables for auth (never hardcode credentials)
LINEAR_API_KEY = os.getenv("LINEAR_API_KEY")
JIRA_URL = os.getenv("JIRA_URL", "https://your-domain.atlassian.net")
JIRA_USER = os.getenv("JIRA_USER")
JIRA_API_TOKEN = os.getenv("JIRA_API_TOKEN")
JIRA_PROJECT_KEY = os.getenv("JIRA_PROJECT_KEY", "ENG")

# Validate required env vars
if not all([LINEAR_API_KEY, JIRA_USER, JIRA_API_TOKEN]):
    logger.error("Missing required environment variables. Check LINEAR_API_KEY, JIRA_USER, JIRA_API_TOKEN.")
    raise SystemExit(1)

# Initialize clients with rate limit handling
linear_client = LinearClient(api_key=LINEAR_API_KEY)
jira_client = Jira(
    url=JIRA_URL,
    username=JIRA_USER,
    password=JIRA_API_TOKEN
)

# Map Linear issue statuses to Jira 2026 workflow statuses
STATUS_MAP = {
    "Backlog": "Backlog",
    "Todo": "To Do",
    "In Progress": "In Progress",
    "Done": "Done",
    "Canceled": "Canceled"
}

# Map Linear issue priorities to Jira priority IDs (Jira 2026 uses numeric priority IDs)
PRIORITY_MAP = {
    "No Priority": 5,  # Lowest
    "Low": 4,
    "Medium": 3,
    "High": 2,
    "Urgent": 1  # Highest
}

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def migrate_issue(linear_issue):
    """Migrate a single Linear issue to Jira 2026 with retry logic for transient failures."""
    try:
        # Extract required fields from Linear issue
        issue_data = {
            "summary": linear_issue.title[:255],  # Jira summary max length
            "description": f"Migrated from Linear Issue: {linear_issue.url}\n\n{linear_issue.description or 'No description provided.'}",
            "project": JIRA_PROJECT_KEY,
            "issuetype": "Story" if linear_issue.type == "Story" else "Task",
            "priority": PRIORITY_MAP.get(linear_issue.priority, 3),
            "status": STATUS_MAP.get(linear_issue.state.name, "Backlog"),
            "labels": [tag.name for tag in linear_issue.tags] + ["migrated-from-linear"]
        }

        # Create issue in Jira 2026
        new_issue = jira_client.create_issue(fields=issue_data)
        logger.info(f"Migrated Linear issue {linear_issue.id} to Jira {new_issue.key}")

        # Migrate comments (Linear API returns paginated comments)
        comments = linear_client.issue(linear_issue.id).comments()
        for comment in comments:
            jira_client.add_comment(
                issue=new_issue.key,
                body=f"[Linear Comment by {comment.user.name}]: {comment.body}"
            )

        return new_issue.key
    except Exception as e:
        logger.error(f"Failed to migrate Linear issue {linear_issue.id}: {str(e)}")
        raise  # Retry will catch this

def main():
    """Main migration workflow: fetch all Linear issues and migrate in batches."""
    logger.info("Starting Linear 1.5 to Jira 2026 migration...")
    try:
        # Fetch all issues from Linear 1.5 (filter for active projects only)
        linear_issues = linear_client.issues(
            filter={"project": {"id": {"in": ["proj_123", "proj_456", "proj_789", "proj_012"]}}}  # Our 4 team project IDs
        )
        logger.info(f"Fetched {len(linear_issues)} issues from Linear 1.5")

        migrated_count = 0
        failed_count = 0

        for idx, issue in enumerate(linear_issues, 1):
            try:
                migrate_issue(issue)
                migrated_count +=1
                # Linear API rate limit: 100 requests/min, so throttle
                if idx % 90 == 0:
                    logger.info("Throttling for 60 seconds to respect Linear rate limits...")
                    time.sleep(60)
            except Exception as e:
                logger.error(f"Permanent failure for issue {issue.id}: {str(e)}")
                failed_count +=1

        logger.info(f"Migration complete. Migrated: {migrated_count}, Failed: {failed_count}")

    except Exception as e:
        logger.critical(f"Migration failed catastrophically: {str(e)}")
        raise

if __name__ == "__main__":
    main()

import os
import csv
from datetime import datetime, timedelta
from jira import Jira
from linear_api import LinearClient
import pandas as pd
import matplotlib.pyplot as plt
from tenacity import retry, stop_after_attempt, wait_fixed

# Configure logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)

# Auth config (same as migration script)
JIRA_URL = os.getenv("JIRA_URL")
JIRA_USER = os.getenv("JIRA_USER")
JIRA_API_TOKEN = os.getenv("JIRA_API_TOKEN")
LINEAR_API_KEY = os.getenv("LINEAR_API_KEY")
JIRA_PROJECT_KEY = os.getenv("JIRA_PROJECT_KEY", "ENG")

# Initialize clients
jira = Jira(url=JIRA_URL, username=JIRA_USER, password=JIRA_API_TOKEN)
linear = LinearClient(api_key=LINEAR_API_KEY)

@retry(stop=stop_after_attempt(3), wait=wait_fixed(5))
def fetch_jira_sprint_data(sprint_id):
    """Fetch completed story points for a Jira 2026 sprint with retry logic."""
    try:
        sprint = jira.sprint(sprint_id)
        if sprint.state != "closed":
            logger.warning(f"Sprint {sprint_id} is not closed. Skipping.")
            return None
        # Fetch all completed issues in sprint
        issues = jira.search_issues(
            jql=f"sprint = {sprint_id} AND status = Done AND project = {JIRA_PROJECT_KEY}",
            fields=["storyPoints", "id", "key"]
        )
        total_points = sum(issue.fields.storyPoints or 0 for issue in issues)
        return {
            "sprint_id": sprint_id,
            "name": sprint.name,
            "start_date": sprint.startDate,
            "end_date": sprint.endDate,
            "story_points": total_points
        }
    except Exception as e:
        logger.error(f"Failed to fetch Jira sprint {sprint_id}: {str(e)}")
        raise

@retry(stop=stop_after_attempt(3), wait=wait_fixed(5))
def fetch_linear_sprint_data(sprint_id):
    """Fetch completed story points for a Linear 1.5 sprint with retry logic."""
    try:
        sprint = linear.sprint(sprint_id)
        if not sprint.endDate or datetime.fromisoformat(sprint.endDate) > datetime.now():
            logger.warning(f"Linear sprint {sprint_id} is not closed. Skipping.")
            return None
        issues = linear.issues(filter={"sprint": {"id": {"eq": sprint_id}}})
        total_points = sum(issue.estimate or 0 for issue in issues if issue.state.name == "Done")
        return {
            "sprint_id": sprint_id,
            "name": sprint.name,
            "start_date": sprint.startDate,
            "end_date": sprint.endDate,
            "story_points": total_points
        }
    except Exception as e:
        logger.error(f"Failed to fetch Linear sprint {sprint_id}: {str(e)}")
        raise

def calculate_velocity_comparison():
    """Compare Linear 1.5 and Jira 2026 sprint velocity over 6 months."""
    # Define comparison period: 3 months pre-migration (Linear), 3 months post-migration (Jira)
    pre_migration_start = datetime.now() - timedelta(days=180)
    pre_migration_end = datetime.now() - timedelta(days=90)
    post_migration_start = datetime.now() - timedelta(days=89)
    post_migration_end = datetime.now()

    # Fetch Linear sprints (pre-migration)
    logger.info("Fetching Linear 1.5 sprint data...")
    linear_sprints = linear.sprints(
        filter={
            "startDate": {"gte": pre_migration_start.isoformat()},
            "endDate": {"lte": pre_migration_end.isoformat()},
            "state": {"eq": "closed"}
        }
    )
    linear_data = [fetch_linear_sprint_data(s.id) for s in linear_sprints]
    linear_data = [d for d in linear_data if d is not None]

    # Fetch Jira sprints (post-migration)
    logger.info("Fetching Jira 2026 sprint data...")
    jira_sprints = jira.search_sprints(
        jql=f"project = {JIRA_PROJECT_KEY} AND startDate >= {post_migration_start.strftime('%Y-%m-%d')} AND endDate <= {post_migration_end.strftime('%Y-%m-%d')} AND state = closed"
    )
    jira_data = [fetch_jira_sprint_data(s.id) for s in jira_sprints]
    jira_data = [d for d in jira_data if d is not None]

    # Calculate average velocity
    linear_avg = pd.DataFrame(linear_data)["story_points"].mean() if linear_data else 0
    jira_avg = pd.DataFrame(jira_data)["story_points"].mean() if jira_data else 0

    # Calculate percentage increase
    if linear_avg == 0:
        logger.error("No Linear sprint data found. Cannot calculate comparison.")
        return
    velocity_increase = ((jira_avg - linear_avg) / linear_avg) * 100

    # Log and export results
    logger.info(f"Linear 1.5 Avg Velocity: {linear_avg:.2f} story points/sprint")
    logger.info(f"Jira 2026 Avg Velocity: {jira_avg:.2f} story points/sprint")
    logger.info(f"Velocity Increase: {velocity_increase:.2f}%")

    # Export to CSV for audit
    with open("velocity_comparison.csv", "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["source", "sprint_id", "name", "story_points", "start_date"])
        writer.writeheader()
        for d in linear_data:
            writer.writerow({**d, "source": "Linear 1.5"})
        for d in jira_data:
            writer.writerow({**d, "source": "Jira 2026"})

    # Generate visualization
    df = pd.DataFrame(linear_data + jira_data)
    df["start_date"] = pd.to_datetime(df["start_date"])
    df.sort_values("start_date", inplace=True)
    plt.figure(figsize=(12,6))
    plt.plot(df[df["source"]=="Linear 1.5"]["start_date"], df[df["source"]=="Linear 1.5"]["story_points"], label="Linear 1.5", marker="o")
    plt.plot(df[df["source"]=="Jira 2026"]["start_date"], df[df["source"]=="Jira 2026"]["story_points"], label="Jira 2026", marker="s")
    plt.axvline(x=datetime.now() - timedelta(days=90), color="r", linestyle="--", label="Migration Date")
    plt.xlabel("Sprint Start Date")
    plt.ylabel("Story Points Completed")
    plt.title("Sprint Velocity: Linear 1.5 vs Jira 2026")
    plt.legend()
    plt.savefig("velocity_comparison.png")
    logger.info("Saved velocity visualization to velocity_comparison.png")

if __name__ == "__main__":
    calculate_velocity_comparison()

import os
import logging
from datetime import datetime, timedelta
from jira import Jira
from tenacity import retry, stop_after_attempt, wait_exponential
import json

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("jira_automation.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)

# Auth config
JIRA_URL = os.getenv("JIRA_URL")
JIRA_USER = os.getenv("JIRA_USER")
JIRA_API_TOKEN = os.getenv("JIRA_API_TOKEN")
JIRA_PROJECT_KEY = os.getenv("JIRA_PROJECT_KEY", "ENG")
JIRA_BOARD_ID = os.getenv("JIRA_BOARD_ID", "101")  # Our team's board ID

# Initialize Jira 2026 client with AI feature support
jira = Jira(
    url=JIRA_URL,
    username=JIRA_USER,
    password=JIRA_API_TOKEN,
    headers={"X-Atlassian-2026-AI-Preview": "true"}  # Enable Jira 2026 AI features
)

# Configuration for sprint planning automation
SPRINT_LENGTH_DAYS = 14
MAX_STORY_POINTS_PER_SPRINT = 40  # Team capacity
AI_TRIAGE_CONFIDENCE_THRESHOLD = 0.85  # Only auto-assign high confidence triage

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def run_ai_backlog_triage():
    """Use Jira 2026 AI to triage and prioritize backlog issues."""
    try:
        logger.info("Running Jira 2026 AI backlog triage...")
        # Call Jira 2026 AI triage endpoint (undocumented but stable in 2026.0.1)
        response = jira.session.post(
            f"{JIRA_URL}/rest/ai/2026/backlog/triage",
            json={
                "projectKey": JIRA_PROJECT_KEY,
                "boardId": JIRA_BOARD_ID,
                "confidenceThreshold": AI_TRIAGE_CONFIDENCE_THRESHOLD,
                "prioritizeBy": "business_value"  # Jira 2026 AI supports business_value, effort, risk
            }
        )
        response.raise_for_status()
        triage_results = response.json()

        logger.info(f"AI triage completed. Processed {len(triage_results['issues'])} issues.")
        return triage_results
    except Exception as e:
        logger.error(f"AI triage failed: {str(e)}")
        raise

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def create_next_sprint(triage_results):
    """Create the next sprint with AI-prioritized issues up to team capacity."""
    try:
        # Calculate sprint dates
        last_sprint = jira.search_sprints(
            jql=f"project = {JIRA_PROJECT_KEY} AND state = closed ORDER BY endDate DESC"
        )[0]
        start_date = datetime.fromisoformat(last_sprint.endDate) + timedelta(days=1)
        end_date = start_date + timedelta(days=SPRINT_LENGTH_DAYS)

        # Create new sprint
        new_sprint = jira.create_sprint(
            name=f"Sprint {datetime.now().strftime('%Y-%m-%d')}",
            board_id=JIRA_BOARD_ID,
            start_date=start_date.isoformat(),
            end_date=end_date.isoformat()
        )
        logger.info(f"Created new sprint: {new_sprint.name} (ID: {new_sprint.id})")

        # Add AI-prioritized issues up to max capacity
        current_points = 0
        added_issues = 0
        for issue in triage_results["issues"]:
            if current_points >= MAX_STORY_POINTS_PER_SPRINT:
                logger.info(f"Reached max capacity ({MAX_STORY_POINTS_PER_SPRINT} points). Stopping issue addition.")
                break
            issue_points = issue.get("storyPoints", 0)
            if current_points + issue_points > MAX_STORY_POINTS_PER_SPRINT:
                continue  # Skip issues that would exceed capacity
            # Add issue to sprint
            jira.add_issues_to_sprint(sprint_id=new_sprint.id, issue_keys=[issue["key"]])
            current_points += issue_points
            added_issues +=1
            logger.info(f"Added issue {issue['key']} ({issue_points} points) to sprint. Total points: {current_points}")

        logger.info(f"Sprint planning complete. Added {added_issues} issues ({current_points} points) to {new_sprint.name}")
        return new_sprint
    except Exception as e:
        logger.error(f"Sprint creation failed: {str(e)}")
        raise

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def send_sprint_planning_notification(sprint, triage_results):
    """Send Slack notification with sprint details (using Jira 2026's native Slack integration)."""
    try:
        response = jira.session.post(
            f"{JIRA_URL}/rest/notify/2026/slack",
            json={
                "channel": "#eng-sprints",
                "text": f"✅ Sprint {sprint.name} created with {len(triage_results['issues'])} issues, {sum(i.get('storyPoints',0) for i in triage_results['issues'])} story points.",
                "attachments": [
                    {
                        "title": "Sprint Details",
                        "fields": [
                            {"title": "Start Date", "value": sprint.startDate, "short": True},
                            {"title": "End Date", "value": sprint.endDate, "short": True},
                            {"title": "Total Story Points", "value": sum(i.get('storyPoints',0) for i in triage_results['issues']), "short": True}
                        ]
                    }
                ]
            }
        )
        response.raise_for_status()
        logger.info("Sent sprint planning notification to Slack.")
    except Exception as e:
        logger.error(f"Failed to send Slack notification: {str(e)}")
        raise

def main():
    """Main automation workflow: triage backlog, create sprint, notify team."""
    logger.info("Starting Jira 2026 sprint planning automation...")
    try:
        # Run AI triage
        triage_results = run_ai_backlog_triage()

        # Create next sprint with triaged issues
        new_sprint = create_next_sprint(triage_results)

        # Send notification
        send_sprint_planning_notification(new_sprint, triage_results)

        # Export triage results for audit
        with open(f"triage_results_{datetime.now().strftime('%Y%m%d')}.json", "w") as f:
            json.dump(triage_results, f, indent=2)
        logger.info("Exported triage results to JSON.")

        logger.info("Sprint planning automation completed successfully.")
    except Exception as e:
        logger.critical(f"Automation failed catastrophically: {str(e)}")
        raise

if __name__ == "__main__":
    main()

def sync_issue_title(linear_issue_id, new_title):
    # Update Linear first
    linear_client.issue(linear_issue_id).update(title=new_title)
    # Find corresponding Jira issue
    jira_issue = jira.search_issues(f"labels = 'migrated-from-linear' AND summary ~ '{linear_issue_id}'")[0]
    # Update Jira
    jira_client.update_issue(jira_issue.key, fields={"summary": new_title})

def import_linear_velocity_to_jira(linear_sprint_data):
    for sprint in linear_sprint_data:
        jira.session.post(
            f"{JIRA_URL}/rest/ai/2026/velocity/train",
            json={
                "sprintId": sprint["id"],
                "storyPoints": sprint["story_points"],
                "startDate": sprint["start_date"],
                "endDate": sprint["end_date"]
            }
        )

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(min=2, max=10))
def safe_linear_api_call(issue_id):
    try:
        return linear_client.issue(issue_id).comments()
    except Exception as e:
        logger.error(f"Linear API call failed for {issue_id}: {e}")
        raise