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

package/dist/lib/verify.js

@@ -15,30 +15,30 @@ async function verifyConditions(pluginConfig, context) {
     // Check for API key in config or environment
     const linearApiKey = apiKey || process.env.LINEAR_API_KEY;
     if (!linearApiKey) {
-        throw new error_1.default("No Linear API key found", "ENOLINEARTOKEN", "Please provide a Linear API key via plugin config or LINEAR_API_KEY environment variable.");
+        throw new error_1.default('No Linear API key found', 'ENOLINEARTOKEN', 'Please provide a Linear API key via plugin config or LINEAR_API_KEY environment variable.');
     }
     // Validate team keys format if provided
     const teamKeyPattern = /^[A-Z]+$/;
     const branchPattern = /^[A-Za-z0-9._-]+\/[A-Za-z0-9][A-Za-z0-9._-]*$/;
     const invalidTeamKeys = teamKeys.filter((key) => !teamKeyPattern.test(key) && !branchPattern.test(key));
     if (invalidTeamKeys.length > 0) {
-        throw new error_1.default("Invalid team key format", "EINVALIDTEAMKEY", "Team keys must be uppercase letters (e.g. SD) or branch names (e.g. caio/tk-519-title). " +
-            `Invalid: ${invalidTeamKeys.join(", ")}`);
+        throw new error_1.default('Invalid team key format', 'EINVALIDTEAMKEY', 'Team keys must be uppercase letters (e.g. SD) or branch names (e.g. caio/tk-519-title). ' +
+            `Invalid: ${invalidTeamKeys.join(', ')}`);
     }
     // Test API connection
     const client = new linear_client_1.LinearClient(linearApiKey);
     try {
-        logger.log("Verifying Linear API access...");
+        logger.log('Verifying Linear API access...');
         await client.testConnection();
-        logger.log("✓ Linear API access verified");
+        logger.log('✓ Linear API access verified');
     }
     catch (error) {
-        throw new error_1.default("Failed to connect to Linear API", "ELINEARCONNECTION", `Could not connect to Linear API: ${error.message}`);
+        throw new error_1.default('Failed to connect to Linear API', 'ELINEARCONNECTION', `Could not connect to Linear API: ${error.message}`);
     }
     // Store validated config in context for other lifecycle methods
     context.linear = {
         apiKey: linearApiKey,
         teamKeys: teamKeys.length > 0 ? teamKeys : null,
-        labelPrefix: pluginConfig.labelPrefix || "v",
+        labelPrefix: pluginConfig.labelPrefix || 'v',
     };
 }

package/dist/lib/verify.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 // Minimal ESM mocks
-jest.mock("@semantic-release/error", () => {
+jest.mock('@semantic-release/error', () => {
     class SemanticReleaseError extends Error {
         code;
         constructor(message, code) {
@@ -11,32 +11,32 @@ jest.mock("@semantic-release/error", () => {
     }
     return { __esModule: true, default: SemanticReleaseError };
 });
-jest.mock("./linear-client", () => ({
+jest.mock('./linear-client', () => ({
     LinearClient: jest.fn().mockImplementation(() => ({
         testConnection: jest.fn().mockResolvedValue({}),
     })),
 }));
-jest.mock("node-fetch", () => ({ __esModule: true, default: jest.fn() }));
+jest.mock('node-fetch', () => ({ __esModule: true, default: jest.fn() }));
 const verify_1 = require("./verify");
-describe("verify", () => {
+describe('verify', () => {
     const mockContext = {
         logger: { log: jest.fn(), error: jest.fn() },
     };
     beforeEach(() => {
         delete process.env.LINEAR_API_KEY;
     });
-    test("throws without API key", async () => {
-        await expect((0, verify_1.verifyConditions)({}, mockContext)).rejects.toThrow("No Linear API key found");
+    test('throws without API key', async () => {
+        await expect((0, verify_1.verifyConditions)({}, mockContext)).rejects.toThrow('No Linear API key found');
     });
-    test("validates team key format", async () => {
+    test('validates team key format', async () => {
         // Validation happens BEFORE the API call, so it fails fast
-        await expect((0, verify_1.verifyConditions)({ apiKey: "test", teamKeys: ["eng-123"] }, mockContext)).rejects.toThrow("Invalid team key format");
+        await expect((0, verify_1.verifyConditions)({ apiKey: 'test', teamKeys: ['eng-123'] }, mockContext)).rejects.toThrow('Invalid team key format');
     });
-    test("accepts valid branch like team key", async () => {
+    test('accepts valid branch like team key', async () => {
         // Accepts branch patterns without hitting API
         await expect((0, verify_1.verifyConditions)({
-            apiKey: "test",
-            teamKeys: ["caio/tk-519-title"],
+            apiKey: 'test',
+            teamKeys: ['caio/tk-519-title'],
         }, mockContext)).resolves.toBeUndefined();
     });
 });

package/dist/types.d.ts

@@ -11,10 +11,6 @@ export interface PluginConfig {
     addComment?: boolean;
     /** Preview changes without updating Linear (default: false) */
     dryRun?: boolean;
-    /** Branches to skip unless they contain issue IDs (default: ["main", "master", "develop", "staging", "production"]) */
-    skipBranches?: string[];
-    /** Require issues in branch name to process (default: true) */
-    requireIssueInBranch?: boolean;
 }
 export interface LinearContext {
     apiKey: string;
@@ -34,13 +30,8 @@ export interface LinearLabel {
     name: string;
     color?: string;
 }
-export interface IssueUpdateResult {
-    issueId: string;
-    status: "updated" | "failed" | "not_found";
-    error?: string;
-}
 export interface LinearViewer {
     id: string;
     name: string;
 }
-export type ReleaseType = "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease";
+export type ReleaseType = 'major' | 'premajor' | 'minor' | 'preminor' | 'patch' | 'prepatch' | 'prerelease';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "semantic-release-linear-app",
-    "version": "0.3.0-next.2",
+    "version": "0.3.0-next.4",
     "description": "Semantic-release plugin to update Linear issues with version labels",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -46,29 +46,28 @@
     },
     "dependencies": {
         "@semantic-release/error": "^4.0.0",
-        "execa": "^9.6.0",
+        "execa": "^9.6.1",
         "node-fetch": "^3.3.2"
     },
     "devDependencies": {
-        "@semantic-release/changelog": "^6.0.3",
         "@semantic-release/commit-analyzer": "^13.0.1",
         "@semantic-release/git": "^10.0.1",
-        "@semantic-release/github": "^11.0.6",
-        "@semantic-release/npm": "^12.0.2",
+        "@semantic-release/github": "^12.0.2",
+        "@semantic-release/npm": "^13.1.3",
         "@semantic-release/release-notes-generator": "^14.1.0",
         "@types/jest": "^30.0.0",
-        "@types/node": "^24.7.0",
+        "@types/node": "^25.0.1",
         "@types/node-fetch": "^2.6.13",
         "@types/semantic-release": "^21.1.0",
-        "@typescript-eslint/eslint-plugin": "^8.46.0",
-        "@typescript-eslint/parser": "^8.46.0",
-        "eslint": "^9.37.0",
+        "@typescript-eslint/eslint-plugin": "^8.49.0",
+        "@typescript-eslint/parser": "^8.49.0",
+        "eslint": "^9.39.2",
         "husky": "^9.1.7",
         "jest": "^30.2.0",
-        "lint-staged": "^16.2.3",
-        "prettier": "^3.6.2",
-        "semantic-release": "^24.2.9",
-        "ts-jest": "^29.4.4",
+        "lint-staged": "^16.2.7",
+        "prettier": "^3.7.4",
+        "semantic-release": "^25.0.2",
+        "ts-jest": "^29.4.6",
         "typescript": "^5.9.3"
     },
     "files": [

package/src/lib/linear-client.ts

@@ -1,5 +1,5 @@
-import fetch from "node-fetch";
-import { LinearIssue, LinearLabel, LinearViewer } from "../types";
+import fetch from 'node-fetch';
+import { LinearIssue, LinearLabel, LinearViewer } from '../types';
 
 interface GraphQLResponse<T> {
   data?: T;
@@ -11,7 +11,7 @@ interface GraphQLResponse<T> {
  */
 export class LinearClient {
   private apiKey: string;
-  private apiUrl: string = "https://api.linear.app/graphql";
+  private apiUrl: string = 'https://api.linear.app/graphql';
 
   constructor(apiKey: string) {
     this.apiKey = apiKey;
@@ -25,10 +25,10 @@ export class LinearClient {
     variables: Record<string, unknown> = {},
   ): Promise<T> {
     const response = await fetch(this.apiUrl, {
-      method: "POST",
+      method: 'POST',
       headers: {
         Authorization: this.apiKey,
-        "Content-Type": "application/json",
+        'Content-Type': 'application/json',
       },
       body: JSON.stringify({ query, variables }),
     });
@@ -40,7 +40,7 @@ export class LinearClient {
     }
 
     if (!data.data) {
-      throw new Error("No data returned from Linear API");
+      throw new Error('No data returned from Linear API');
     }
 
     return data.data;
@@ -66,10 +66,7 @@ export class LinearClient {
   /**
    * Find or create a label
    */
-  async ensureLabel(
-    name: string,
-    color: string = "#4752C4",
-  ): Promise<LinearLabel> {
+  async ensureLabel(name: string, color: string = '#4752C4'): Promise<LinearLabel> {
     // First, try to find existing label
     const searchQuery = `
       query FindLabel($name: String!) {
@@ -143,10 +140,7 @@ export class LinearClient {
   /**
    * Add label to issue
    */
-  async addLabelToIssue(
-    issueId: string,
-    labelId: string,
-  ): Promise<LinearIssue> {
+  async addLabelToIssue(issueId: string, labelId: string): Promise<LinearIssue> {
     const mutation = `
       mutation AddLabel($issueId: String!, $labelId: String!) {
         issueUpdate(
@@ -178,16 +172,11 @@ export class LinearClient {
   /**
    * Remove old version labels from issue
    */
-  async removeVersionLabels(
-    issueId: string,
-    labelPrefix: string,
-  ): Promise<LinearIssue | null> {
+  async removeVersionLabels(issueId: string, labelPrefix: string): Promise<LinearIssue | null> {
     const issue = await this.getIssue(issueId);
     if (!issue) return null;
 
-    const versionLabels = issue.labels.nodes.filter((label) =>
-      label.name.startsWith(labelPrefix),
-    );
+    const versionLabels = issue.labels.nodes.filter((label) => label.name.startsWith(labelPrefix));
 
     if (versionLabels.length === 0) return issue;
 

package/src/lib/parse-issues.test.ts

@@ -1,49 +1,28 @@
-import { parseIssuesFromBranch, shouldProcessBranch } from "./parse-issues";
+import { parseIssuesFromBranch } from './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 = 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 = 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 = parseIssuesFromBranch(branchName, ["ENG"]);
-    expect(result).toEqual(["ENG-123"]);
+  test('filters by team keys when provided', () => {
+    const branchName = 'feature/ENG-123-OTHER-456';
+    const result = 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 = parseIssuesFromBranch(branchName);
     expect(result).toEqual([]);
   });
-
-  test("shouldProcessBranch returns false for skip branches without issues", () => {
-    expect(shouldProcessBranch("main", ["main", "master"])).toBe(false);
-    expect(shouldProcessBranch("master", ["main", "master"])).toBe(false);
-  });
-
-  test("shouldProcessBranch returns true for skip branches with issues", () => {
-    expect(shouldProcessBranch("main-ENG-123", ["main", "master"])).toBe(true);
-  });
-
-  test("shouldProcessBranch returns true for feature branches with issues", () => {
-    expect(shouldProcessBranch("feature/ENG-123", ["main", "master"])).toBe(
-      true,
-    );
-  });
-
-  test("shouldProcessBranch returns false for feature branches without issues", () => {
-    expect(shouldProcessBranch("feature/no-issues", ["main", "master"])).toBe(
-      false,
-    );
-  });
 });

package/src/lib/parse-issues.ts

@@ -16,10 +16,10 @@ export function parseIssuesFromBranch(
   const issues = new Set<string>();
 
   // 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) {
@@ -28,30 +28,3 @@ export function parseIssuesFromBranch(
 
   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
- */
-export function shouldProcessBranch(
-  branchName: string,
-  skipBranches: string[] = [
-    "main",
-    "master",
-    "develop",
-    "staging",
-    "production",
-  ],
-): boolean {
-  // 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/src/lib/success.ts

@@ -1,8 +1,8 @@
-import { SuccessContext } from "semantic-release";
-import { execa } from "execa";
-import { LinearClient } from "./linear-client";
-import { parseIssuesFromBranch } from "./parse-issues";
-import { PluginConfig, LinearContext, ReleaseType } from "../types";
+import { SuccessContext } from 'semantic-release';
+import { execa } from 'execa';
+import { LinearClient } from './linear-client';
+import { parseIssuesFromBranch } from './parse-issues';
+import { PluginConfig, LinearContext, ReleaseType } from '../types';
 
 interface ExtendedContext extends SuccessContext {
   linear?: LinearContext;
@@ -13,37 +13,38 @@ interface ExtendedContext extends SuccessContext {
  */
 async function findSourceBranches(
   commits: readonly { hash: string }[],
-  logger: SuccessContext["logger"],
+  logger: SuccessContext['logger'],
 ): Promise<Set<string>> {
   const branches = new Set<string>();
+  const skipBranches = ['main', 'master', 'develop', 'stable', 'HEAD'];
 
   if (commits.length === 0) return branches;
 
-  try {
-    // Get all branches that contain these commits
-    const { stdout } = await execa("git", [
-      "branch",
-      "-r",
-      "--contains",
-      commits[0].hash,
-      "--merged",
-    ]);
-
-    // Parse remote branch names
-    const branchLines = stdout.split("\n").map((b: string) => 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 execa('git', [
+        'branch',
+        '-r',
+        '--contains',
+        commit.hash,
+        '--merged',
+      ]);
+
+      const branchLines = stdout.split('\n').map((b: string) => 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 as Error).message}`);
+  }
+
+  if (branches.size > 0) {
+    logger.log(`Found source branches: ${Array.from(branches).join(', ')}`);
   }
 
   return branches;
@@ -52,33 +53,26 @@ async function findSourceBranches(
 /**
  * Update Linear issues after a successful release
  */
-export async function success(
-  pluginConfig: PluginConfig,
-  context: ExtendedContext,
-): Promise<void> {
+export async function success(pluginConfig: PluginConfig, context: ExtendedContext): Promise<void> {
   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;
   }
 
@@ -90,30 +84,30 @@ export async function success(
   }
 
   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(", ")} ` +
+    `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 LinearClient(linear.apiKey);
-  const version = nextRelease.version;
-  const channel = nextRelease.channel || "latest";
-  const labelName = `${linear.labelPrefix}${version}`;
   const labelColor = getLabelColor(nextRelease.type as ReleaseType);
 
   // Ensure the version label exists
@@ -127,7 +121,7 @@ export async function success(
         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
@@ -140,37 +134,34 @@ export async function success(
 
         // 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",
+    (r) => r.status === 'fulfilled' && r.value?.status === 'updated',
   ).length;
   const failed = results.filter(
-    (r) => r.status === "rejected" || r.value?.status === "failed",
+    (r) => r.status === 'rejected' || r.value?.status === 'failed',
   ).length;
   const notFound = results.filter(
-    (r) => r.status === "fulfilled" && r.value?.status === "not_found",
+    (r) => r.status === 'fulfilled' && r.value?.status === 'not_found',
   ).length;
 
-  logger.log(
-    `Linear update complete: ${updated} updated, ${failed} failed, ${notFound} not found`,
-  );
+  logger.log(`Linear update complete: ${updated} updated, ${failed} failed, ${notFound} not found`);
 }
 
 /**
@@ -178,14 +169,14 @@ export async function success(
  */
 function getLabelColor(releaseType: ReleaseType): string {
   const colors: Record<ReleaseType, string> = {
-    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/src/lib/verify.test.ts

@@ -1,5 +1,5 @@
 // Minimal ESM mocks
-jest.mock("@semantic-release/error", () => {
+jest.mock('@semantic-release/error', () => {
   class SemanticReleaseError extends Error {
     code: string;
     constructor(message: string, code: string) {
@@ -10,18 +10,18 @@ jest.mock("@semantic-release/error", () => {
   return { __esModule: true, default: SemanticReleaseError };
 });
 
-jest.mock("./linear-client", () => ({
+jest.mock('./linear-client', () => ({
   LinearClient: jest.fn().mockImplementation(() => ({
     testConnection: jest.fn().mockResolvedValue({}),
   })),
 }));
 
-jest.mock("node-fetch", () => ({ __esModule: true, default: jest.fn() }));
+jest.mock('node-fetch', () => ({ __esModule: true, default: jest.fn() }));
 
-import { verifyConditions } from "./verify";
-import { VerifyConditionsContext } from "semantic-release";
+import { verifyConditions } from './verify';
+import { VerifyConditionsContext } from 'semantic-release';
 
-describe("verify", () => {
+describe('verify', () => {
   const mockContext = {
     logger: { log: jest.fn(), error: jest.fn() },
   } as VerifyConditionsContext;
@@ -30,26 +30,24 @@ describe("verify", () => {
     delete process.env.LINEAR_API_KEY;
   });
 
-  test("throws without API key", async () => {
-    await expect(verifyConditions({}, mockContext)).rejects.toThrow(
-      "No Linear API key found",
-    );
+  test('throws without API key', async () => {
+    await expect(verifyConditions({}, mockContext)).rejects.toThrow('No Linear API key found');
   });
 
-  test("validates team key format", async () => {
+  test('validates team key format', async () => {
     // Validation happens BEFORE the API call, so it fails fast
     await expect(
-      verifyConditions({ apiKey: "test", teamKeys: ["eng-123"] }, mockContext),
-    ).rejects.toThrow("Invalid team key format");
+      verifyConditions({ apiKey: 'test', teamKeys: ['eng-123'] }, mockContext),
+    ).rejects.toThrow('Invalid team key format');
   });
 
-  test("accepts valid branch like team key", async () => {
+  test('accepts valid branch like team key', async () => {
     // Accepts branch patterns without hitting API
     await expect(
       verifyConditions(
         {
-          apiKey: "test",
-          teamKeys: ["caio/tk-519-title"],
+          apiKey: 'test',
+          teamKeys: ['caio/tk-519-title'],
         },
         mockContext,
       ),