semantic-release-linear-app 0.3.0-next.2 → 0.3.0-next.4

package/README.md

@@ -1,262 +1,61 @@
-# semantic-release-linear
+# semantic-release-linear-app
 
-> A [semantic-release](https://github.com/semantic-release/semantic-release) plugin that updates Linear issues with version labels based on branch names.
-
-## Features
-
-- 🌿 Extracts Linear issue IDs from branch names
-- 🏷️ Automatically adds version labels to Linear issues
-- 🎨 Color-coded labels based on release type
-- 🧹 Removes old version labels (configurable)
-- 💬 Adds release comments to issues (optional)
-- ⚡ Batch operations for efficiency
-- 📝 Full TypeScript support
+A [semantic-release](https://github.com/semantic-release/semantic-release) plugin that adds version labels to Linear issues based on branch names.
 
 ## Install
 
 ```bash
-npm install --save-dev semantic-release-linear
+npm install --save-dev semantic-release-linear-app
 ```
 
-## Quick Start
+## Setup
 
-1. **Configure semantic-release** (`.releaserc.json`):
+1. Add to your `.releaserc.json`:
 
 ```json
 {
   "plugins": [
     "@semantic-release/commit-analyzer",
     "@semantic-release/release-notes-generator",
-    ["semantic-release-linear", {
-      "teamKeys": ["ENG", "FEAT", "BUG"]
+    ["semantic-release-linear-app", {
+      "teamKeys": ["ENG", "FEAT"]
     }],
     "@semantic-release/github"
   ]
 }
 ```
 
-2. **Set your Linear API key**:
-
-```bash
-export LINEAR_API_KEY=lin_api_xxx
-```
+2. Set `LINEAR_API_KEY` environment variable (create at Linear Settings > API)
 
-3. **Use proper branch names**:
+3. Use branch names with Linear issue IDs:
 
-```bash
-git checkout -b feature/ENG-123-add-authentication
-git checkout -b bugfix/FEAT-456-fix-validation
-git checkout -b ENG-789-quick-fix
+```
+feature/ENG-123-add-auth
+bugfix/FEAT-456-fix-bug
+ENG-789
 ```
 
-That's it! When semantic-release creates a release from these branches, the corresponding Linear issues will be labeled with the version number.
-
-## Configuration
-
-### Options
+## Options
 
 | Option | Default | Description |
 |--------|---------|-------------|
-| `apiKey` | - | Linear API key (or use `LINEAR_API_KEY` env var) |
-| `teamKeys` | `[]` | Team keys to filter (e.g., `["ENG", "FEAT"]`) |
+| `teamKeys` | `[]` | Team keys to filter (e.g., `["ENG"]`) |
 | `labelPrefix` | `"v"` | Prefix for version labels |
 | `removeOldLabels` | `true` | Remove previous version labels |
-| `addComment` | `false` | Add a release comment to issues |
-| `skipBranches` | `["main", "master", "develop", "staging", "production"]` | Branches to skip unless they contain issues |
-| `requireIssueInBranch` | `true` | Only process branches with Linear issues |
+| `addComment` | `false` | Add release comment to issues |
 | `dryRun` | `false` | Preview without making changes |
 
-### TypeScript Configuration
-
-```typescript
-// .releaserc.ts
-import type { PluginConfig } from 'semantic-release-linear';
-
-const config: PluginConfig = {
-  teamKeys: ['ENG', 'FEAT'],
-  labelPrefix: 'release-',
-  addComment: true,
-  skipBranches: ['main', 'develop']
-};
-
-export default {
-  plugins: [
-    '@semantic-release/commit-analyzer',
-    '@semantic-release/release-notes-generator',
-    ['semantic-release-linear', config],
-    '@semantic-release/github'
-  ]
-};
-```
-
-## Branch Naming Convention
-
-### Recommended Patterns
-
-```bash
-# Feature branches
-feature/ENG-123-user-authentication
-feature/FEAT-456-payment-integration
-
-# Bug fixes
-bugfix/BUG-789-login-error
-fix/ENG-101-memory-leak
-
-# Hotfixes
-hotfix/ENG-102-critical-security-patch
-
-# Simple format (still works)
-ENG-103-quick-update
-FEAT-104
-```
-
-### Multiple Issues in One Branch
-
-If you need to update multiple issues, include them all in the branch name:
-
-```bash
-feature/ENG-123-FEAT-456-combined-update
-```
-
-### Enforce Branch Naming
-
-Use Git hooks or CI checks to enforce the naming convention:
-
-```bash
-#!/bin/bash
-# .git/hooks/pre-push or CI script
-
-branch=$(git rev-parse --abbrev-ref HEAD)
-pattern="^(feature|bugfix|fix|hotfix)/[A-Z]+-[0-9]+|^[A-Z]+-[0-9]+"
-
-if ! [[ "$branch" =~ $pattern ]]; then
-  echo "❌ Branch name must include a Linear issue ID"
-  echo "   Example: feature/ENG-123-description"
-  exit 1
-fi
-```
-
-## How It Works
-
-1. **Branch Detection**: When semantic-release runs, it reads the current branch name
-2. **Issue Extraction**: Extracts Linear issue IDs (e.g., `ENG-123`) from the branch
-3. **Label Creation**: Creates a version label if needed (e.g., `v1.2.3`)
-4. **Issue Update**: Applies the label to the Linear issue(s)
-5. **Cleanup**: Optionally removes old version labels
-
-### Label Colors
+## Labels
 
-Labels are color-coded by release type:
+Labels are created based on version and channel:
 
-- 🔴 **Major** (breaking changes) - Red
-- 🟠 **Minor** (new features) - Orange  
-- 🟢 **Patch** (bug fixes) - Green
-- 🟣 **Prerelease** - Purple
+- Default channel: `v1.2.3`
+- Beta/next channels: `v1.2.3-beta`, `v1.2.3-next`
 
-## Dry Run Mode
-
-Test what will happen without making changes:
-
-```javascript
-{
-  "plugins": [
-    ["semantic-release-linear", {
-      "dryRun": true
-    }]
-  ]
-}
-```
-
-Output:
-```
-[semantic-release] [semantic-release-linear] Found 1 Linear issue(s) in branch "feature/ENG-123-auth": ENG-123
-[semantic-release] [semantic-release-linear] [Dry run] Would update issues: ["ENG-123"]
-[semantic-release] [semantic-release-linear] [Dry run] Would apply label: v1.2.3
-```
-
-## Linear API Setup
-
-1. Go to **Linear Settings** → **API** → **Personal API keys**
-2. Create a new key with **write** access
-3. Add to your CI environment as `LINEAR_API_KEY`
-
-## CI Examples
-
-### GitHub Actions
-
-```yaml
-name: Release
-
-on:
-  push:
-    branches: [main, next]
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      
-      - name: Setup Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: 18
-          
-      - name: Install dependencies
-        run: npm ci
-        
-      - name: Release
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-          LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}
-        run: npx semantic-release
-```
-
-## FAQ
-
-### Why only branch names?
-
-Extracting from commits is unreliable - developers forget, commits get squashed, and there's no enforcement. Branch names are:
-- Required for every PR
-- Easily enforced via Git hooks
-- Visible in PR lists
-- A single source of truth
-
-### What about releases from main/master?
-
-You have three options:
-
-1. **Skip them** (default): Set `requireIssueInBranch: true`
-2. **Tag main with an issue**: `git checkout main-ENG-123`  
-3. **Allow all branches**: Set `requireIssueInBranch: false`
-
-### Can I update multiple issues?
-
-Yes, include multiple issue IDs in your branch name:
-```bash
-feature/ENG-123-FEAT-456-big-feature
-```
-
-### What if my branch doesn't have an issue?
-
-The plugin will skip it (unless `requireIssueInBranch: false`). This is intentional - not every release needs to update Linear.
-
-## Troubleshooting
-
-### Issues not being detected
-
-1. Check branch name: `git rev-parse --abbrev-ref HEAD`
-2. Verify format matches: `TEAM-NUMBER`
-3. Check team keys filter if configured
-4. Run with `dryRun: true` to debug
-
-### API errors
-
-- Verify API key has write access
-- Check Linear workspace permissions
-- Ensure network connectivity in CI
+Colors indicate release type: red (major), orange (minor), green (patch), purple (prerelease).
 
 ## License
 
-MIT
+MIT
+
+<!-- SD-1135 e2e test v2 -->

package/dist/lib/linear-client.d.ts

@@ -1,4 +1,4 @@
-import { LinearIssue, LinearLabel, LinearViewer } from "../types";
+import { LinearIssue, LinearLabel, LinearViewer } from '../types';
 /**
  * Linear API client for GraphQL operations
  */

package/dist/lib/linear-client.js

@@ -10,7 +10,7 @@ const node_fetch_1 = __importDefault(require("node-fetch"));
  */
 class LinearClient {
     apiKey;
-    apiUrl = "https://api.linear.app/graphql";
+    apiUrl = 'https://api.linear.app/graphql';
     constructor(apiKey) {
         this.apiKey = apiKey;
     }
@@ -19,10 +19,10 @@ class LinearClient {
      */
     async query(query, variables = {}) {
         const response = await (0, node_fetch_1.default)(this.apiUrl, {
-            method: "POST",
+            method: 'POST',
             headers: {
                 Authorization: this.apiKey,
-                "Content-Type": "application/json",
+                'Content-Type': 'application/json',
             },
             body: JSON.stringify({ query, variables }),
         });
@@ -31,7 +31,7 @@ class LinearClient {
             throw new Error(`Linear API error: ${data.errors[0].message}`);
         }
         if (!data.data) {
-            throw new Error("No data returned from Linear API");
+            throw new Error('No data returned from Linear API');
         }
         return data.data;
     }
@@ -53,7 +53,7 @@ class LinearClient {
     /**
      * Find or create a label
      */
-    async ensureLabel(name, color = "#4752C4") {
+    async ensureLabel(name, color = '#4752C4') {
         // First, try to find existing label
         const searchQuery = `
       query FindLabel($name: String!) {

package/dist/lib/parse-issues.d.ts

@@ -9,10 +9,3 @@
  * @returns Array of unique issue identifiers
  */
 export declare function parseIssuesFromBranch(branchName: string, teamKeys?: string[] | null): string[];
-/**
- * Check if branch should be processed for Linear updates
- * @param branchName - The branch name to check
- * @param skipBranches - Branches to skip (default: main, master, develop without issue IDs)
- * @returns true if branch should be processed
- */
-export declare function shouldProcessBranch(branchName: string, skipBranches?: string[]): boolean;

package/dist/lib/parse-issues.js

@@ -5,7 +5,6 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseIssuesFromBranch = parseIssuesFromBranch;
-exports.shouldProcessBranch = shouldProcessBranch;
 /**
  * Extract Linear issue IDs from a branch name
  * @param branchName - The branch name to parse
@@ -15,34 +14,12 @@ exports.shouldProcessBranch = shouldProcessBranch;
 function parseIssuesFromBranch(branchName, teamKeys = null) {
     const issues = new Set();
     // Build regex pattern based on team keys
-    const teamPattern = teamKeys ? `(?:${teamKeys.join("|")})` : "[A-Z]+";
+    const teamPattern = teamKeys ? `(?:${teamKeys.join('|')})` : '[A-Z]+';
     // Pattern matches: feature/ENG-123-description, ENG-123, bugfix/FEAT-45, etc.
-    const issuePattern = new RegExp(`\\b(${teamPattern}-\\d+)\\b`, "gi");
+    const issuePattern = new RegExp(`\\b(${teamPattern}-\\d+)\\b`, 'gi');
     const matches = Array.from(branchName.matchAll(issuePattern));
     for (const match of matches) {
         issues.add(match[1].toUpperCase());
     }
     return Array.from(issues);
 }
-/**
- * Check if branch should be processed for Linear updates
- * @param branchName - The branch name to check
- * @param skipBranches - Branches to skip (default: main, master, develop without issue IDs)
- * @returns true if branch should be processed
- */
-function shouldProcessBranch(branchName, skipBranches = [
-    "main",
-    "master",
-    "develop",
-    "staging",
-    "production",
-]) {
-    // Skip certain branches UNLESS they contain an issue ID
-    if (skipBranches.includes(branchName)) {
-        // These branches are OK if they contain an issue ID
-        const hasIssue = /[A-Z]+-\d+/.test(branchName);
-        return hasIssue;
-    }
-    // Process any other branch that contains an issue ID
-    return /[A-Z]+-\d+/.test(branchName);
-}

package/dist/lib/parse-issues.test.js

@@ -1,39 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const parse_issues_1 = require("./parse-issues");
-describe("parse-issues", () => {
-    test("extracts Linear issue IDs from branch name", () => {
-        const branchName = "feature/ENG-123-add-new-feature";
+describe('parse-issues', () => {
+    test('extracts Linear issue IDs from branch name', () => {
+        const branchName = 'feature/ENG-123-add-new-feature';
         const result = (0, parse_issues_1.parseIssuesFromBranch)(branchName);
-        expect(result).toEqual(["ENG-123"]);
+        expect(result).toEqual(['ENG-123']);
     });
-    test("extracts multiple issue IDs from branch name", () => {
-        const branchName = "fix/ENG-123-FEAT-456-bug-fix";
+    test('extracts multiple issue IDs from branch name', () => {
+        const branchName = 'fix/ENG-123-FEAT-456-bug-fix';
         const result = (0, parse_issues_1.parseIssuesFromBranch)(branchName);
-        expect(result).toEqual(expect.arrayContaining(["ENG-123", "FEAT-456"]));
+        expect(result).toEqual(expect.arrayContaining(['ENG-123', 'FEAT-456']));
         expect(result).toHaveLength(2);
     });
-    test("filters by team keys when provided", () => {
-        const branchName = "feature/ENG-123-OTHER-456";
-        const result = (0, parse_issues_1.parseIssuesFromBranch)(branchName, ["ENG"]);
-        expect(result).toEqual(["ENG-123"]);
+    test('filters by team keys when provided', () => {
+        const branchName = 'feature/ENG-123-OTHER-456';
+        const result = (0, parse_issues_1.parseIssuesFromBranch)(branchName, ['ENG']);
+        expect(result).toEqual(['ENG-123']);
     });
-    test("returns empty array for branch without issues", () => {
-        const branchName = "feature/no-issues-here";
+    test('returns empty array for branch without issues', () => {
+        const branchName = 'feature/no-issues-here';
         const result = (0, parse_issues_1.parseIssuesFromBranch)(branchName);
         expect(result).toEqual([]);
     });
-    test("shouldProcessBranch returns false for skip branches without issues", () => {
-        expect((0, parse_issues_1.shouldProcessBranch)("main", ["main", "master"])).toBe(false);
-        expect((0, parse_issues_1.shouldProcessBranch)("master", ["main", "master"])).toBe(false);
-    });
-    test("shouldProcessBranch returns true for skip branches with issues", () => {
-        expect((0, parse_issues_1.shouldProcessBranch)("main-ENG-123", ["main", "master"])).toBe(true);
-    });
-    test("shouldProcessBranch returns true for feature branches with issues", () => {
-        expect((0, parse_issues_1.shouldProcessBranch)("feature/ENG-123", ["main", "master"])).toBe(true);
-    });
-    test("shouldProcessBranch returns false for feature branches without issues", () => {
-        expect((0, parse_issues_1.shouldProcessBranch)("feature/no-issues", ["main", "master"])).toBe(false);
-    });
 });

package/dist/lib/success.d.ts

@@ -1,5 +1,5 @@
-import { SuccessContext } from "semantic-release";
-import { PluginConfig, LinearContext } from "../types";
+import { SuccessContext } from 'semantic-release';
+import { PluginConfig, LinearContext } from '../types';
 interface ExtendedContext extends SuccessContext {
     linear?: LinearContext;
 }

package/dist/lib/success.js

@@ -9,31 +9,33 @@ const parse_issues_1 = require("./parse-issues");
  */
 async function findSourceBranches(commits, logger) {
     const branches = new Set();
+    const skipBranches = ['main', 'master', 'develop', 'stable', 'HEAD'];
     if (commits.length === 0)
         return branches;
-    try {
-        // Get all branches that contain these commits
-        const { stdout } = await (0, execa_1.execa)("git", [
-            "branch",
-            "-r",
-            "--contains",
-            commits[0].hash,
-            "--merged",
-        ]);
-        // Parse remote branch names
-        const branchLines = stdout.split("\n").map((b) => b.trim());
-        for (const line of branchLines) {
-            // Extract branch name from origin/feature/ENG-123-description
-            const match = line.match(/origin\/(.+)/);
-            if (match &&
-                !["main", "master", "develop", "stable", "HEAD"].includes(match[1])) {
-                branches.add(match[1]);
-                logger.log(`Found source branch: ${match[1]}`);
+    // Check all commits to find all source branches
+    for (const commit of commits) {
+        try {
+            const { stdout } = await (0, execa_1.execa)('git', [
+                'branch',
+                '-r',
+                '--contains',
+                commit.hash,
+                '--merged',
+            ]);
+            const branchLines = stdout.split('\n').map((b) => b.trim());
+            for (const line of branchLines) {
+                const match = line.match(/origin\/(.+)/);
+                if (match && !skipBranches.includes(match[1])) {
+                    branches.add(match[1]);
+                }
             }
         }
+        catch {
+            // Commit might not exist or other git error, continue with next commit
+        }
     }
-    catch (error) {
-        logger.debug(`Git branch lookup failed: ${error.message}`);
+    if (branches.size > 0) {
+        logger.log(`Found source branches: ${Array.from(branches).join(', ')}`);
     }
     return branches;
 }
@@ -43,18 +45,18 @@ async function findSourceBranches(commits, logger) {
 async function success(pluginConfig, context) {
     const { logger, nextRelease, linear, commits } = context;
     if (!linear) {
-        logger.log("Linear context not found, skipping issue updates");
+        logger.log('Linear context not found, skipping issue updates');
         return;
     }
     if (!commits || commits.length === 0) {
-        logger.log("No commits found in release, skipping Linear updates");
+        logger.log('No commits found in release, skipping Linear updates');
         return;
     }
-    const { removeOldLabels = true, addComment = false, dryRun = false, } = pluginConfig;
+    const { removeOldLabels = true, addComment = false, dryRun = false } = pluginConfig;
     // Find all branches that contributed to this release
     const sourceBranches = await findSourceBranches(commits, logger);
     if (sourceBranches.size === 0) {
-        logger.log("No source branches found, skipping Linear updates");
+        logger.log('No source branches found, skipping Linear updates');
         return;
     }
     // Extract Linear issue IDs from all found branches
@@ -64,21 +66,24 @@ async function success(pluginConfig, context) {
         branchIssues.forEach((id) => issueIds.add(id));
     }
     if (issueIds.size === 0) {
-        logger.log(`No Linear issues found in branches: ${Array.from(sourceBranches).join(", ")}`);
+        logger.log(`No Linear issues found in branches: ${Array.from(sourceBranches).join(', ')}`);
         return;
     }
-    logger.log(`Found ${issueIds.size} Linear issue(s): ${Array.from(issueIds).join(", ")} ` +
+    logger.log(`Found ${issueIds.size} Linear issue(s): ${Array.from(issueIds).join(', ')} ` +
         `from ${sourceBranches.size} branch(es)`);
+    // Build label name with optional channel suffix
+    const version = nextRelease.version;
+    const channel = nextRelease.channel;
+    const labelName = channel
+        ? `${linear.labelPrefix}${version}-${channel}`
+        : `${linear.labelPrefix}${version}`;
     if (dryRun) {
-        logger.log("[Dry run] Would update issues:", Array.from(issueIds));
-        logger.log(`[Dry run] Would apply label: ${linear.labelPrefix}${nextRelease.version}`);
+        logger.log('[Dry run] Would update issues:', Array.from(issueIds));
+        logger.log(`[Dry run] Would apply label: ${labelName}`);
         return;
     }
     // Initialize Linear client and prepare label
     const client = new linear_client_1.LinearClient(linear.apiKey);
-    const version = nextRelease.version;
-    const channel = nextRelease.channel || "latest";
-    const labelName = `${linear.labelPrefix}${version}`;
     const labelColor = getLabelColor(nextRelease.type);
     // Ensure the version label exists
     const label = await client.ensureLabel(labelName, labelColor);
@@ -89,7 +94,7 @@ async function success(pluginConfig, context) {
             const issue = await client.getIssue(issueId);
             if (!issue) {
                 logger.warn(`Issue ${issueId} not found in Linear`);
-                return { issueId, status: "not_found" };
+                return { issueId, status: 'not_found' };
             }
             // Remove old version labels if configured
             if (removeOldLabels) {
@@ -99,24 +104,24 @@ async function success(pluginConfig, context) {
             await client.addLabelToIssue(issue.id, label.id);
             // Add comment if configured
             if (addComment) {
-                const emoji = channel === "latest" ? "🚀" : "🔬";
-                const channelText = channel === "latest" ? "" : ` (${channel} channel)`;
+                const emoji = channel ? '🔬' : '🚀';
+                const channelText = channel ? ` (${channel} channel)` : '';
                 const comment = `${emoji} Released in version ${version}${channelText}`;
                 await client.addComment(issue.id, comment);
             }
             logger.log(`✓ Updated issue ${issueId}`);
-            return { issueId, status: "updated" };
+            return { issueId, status: 'updated' };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             logger.error(`Failed to update issue ${issueId}: ${message}`);
-            return { issueId, status: "failed", error: message };
+            return { issueId, status: 'failed', error: message };
         }
     }));
     // Log summary
-    const updated = results.filter((r) => r.status === "fulfilled" && r.value?.status === "updated").length;
-    const failed = results.filter((r) => r.status === "rejected" || r.value?.status === "failed").length;
-    const notFound = results.filter((r) => r.status === "fulfilled" && r.value?.status === "not_found").length;
+    const updated = results.filter((r) => r.status === 'fulfilled' && r.value?.status === 'updated').length;
+    const failed = results.filter((r) => r.status === 'rejected' || r.value?.status === 'failed').length;
+    const notFound = results.filter((r) => r.status === 'fulfilled' && r.value?.status === 'not_found').length;
     logger.log(`Linear update complete: ${updated} updated, ${failed} failed, ${notFound} not found`);
 }
 /**
@@ -124,13 +129,13 @@ async function success(pluginConfig, context) {
  */
 function getLabelColor(releaseType) {
     const colors = {
-        major: "#F44336", // Red for breaking changes
-        premajor: "#E91E63", // Pink for pre-major
-        minor: "#FF9800", // Orange for new features
-        preminor: "#FFC107", // Amber for pre-minor
-        patch: "#4CAF50", // Green for fixes
-        prepatch: "#8BC34A", // Light green for pre-patch
-        prerelease: "#9C27B0", // Purple for prereleases
+        major: '#F44336', // Red for breaking changes
+        premajor: '#E91E63', // Pink for pre-major
+        minor: '#FF9800', // Orange for new features
+        preminor: '#FFC107', // Amber for pre-minor
+        patch: '#4CAF50', // Green for fixes
+        prepatch: '#8BC34A', // Light green for pre-patch
+        prerelease: '#9C27B0', // Purple for prereleases
     };
-    return colors[releaseType] || "#4752C4"; // Default blue
+    return colors[releaseType] || '#4752C4'; // Default blue
 }

package/dist/lib/verify.d.ts

@@ -1,5 +1,5 @@
-import { VerifyConditionsContext } from "semantic-release";
-import { PluginConfig, LinearContext } from "../types";
+import { VerifyConditionsContext } from 'semantic-release';
+import { PluginConfig, LinearContext } from '../types';
 /**
  * Verify the plugin configuration and Linear API access
  */