@hellopearl/dv-gitlab 0.4.4 → 0.5.0

package/src/commands/release-summary.mjs

@@ -1,5 +1,6 @@
 import { execSync } from 'node:child_process';
 import { createSign } from 'node:crypto';
+
 import { log } from '../lib/logger.mjs';
 
 const MAX_COMMITS = 30;
@@ -11,19 +12,22 @@ function env(key, fallback = '') {
 }
 
 function shellQuote(value) {
-  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
 }
 
 function git(command) {
   return execSync(`git ${command}`, {
     encoding: 'utf8',
-    timeout: 60_000,
     stdio: ['ignore', 'pipe', 'pipe'],
+    timeout: 60_000,
   });
 }
 
 export function escapeSlack(text) {
-  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
 }
 
 export function isNoiseCommit(subject) {
@@ -31,18 +35,24 @@ export function isNoiseCommit(subject) {
 }
 
 export function filterNoiseCommits(commits) {
-  return commits.filter((c) => !isNoiseCommit(c));
+  return commits.filter(c => !isNoiseCommit(c));
 }
 
 export function shouldResolveFromSourceBranch(commits) {
-  if (!commits.length || commits.length > 3) return false;
-  const nonMerge = commits.filter((c) => !/^merge\b/i.test(c.trim()));
-  if (!nonMerge.length) return false;
-  return nonMerge.every((c) => /^release:\s*/i.test(c.trim()));
+  if (!commits.length || commits.length > 3) {
+    return false;
+  }
+  const nonMerge = commits.filter(c => !/^merge\b/i.test(c.trim()));
+  if (!nonMerge.length) {
+    return false;
+  }
+  return nonMerge.every(c => /^release:\s*/i.test(c.trim()));
 }
 
 export function getCommitsInRange(from, to) {
-  if (!from || from === '0000000000000000000000000000000000000000') return [];
+  if (!from || from === '0000000000000000000000000000000000000000') {
+    return [];
+  }
   try {
     const raw = git(`log ${from}..${to} --no-merges --format="%s"`);
     return raw.trim().split('\n').filter(Boolean);
@@ -53,18 +63,24 @@ export function getCommitsInRange(from, to) {
 }
 
 export function getCommitsFromSourceBranch(from, to, sourceBranch) {
-  if (!from || from === '0000000000000000000000000000000000000000') return [];
+  if (!from || from === '0000000000000000000000000000000000000000') {
+    return [];
+  }
   try {
     git(`fetch origin ${sourceBranch} --depth=500`);
   } catch (err) {
-    log(`[release-summary] fetch origin/${sourceBranch} failed: ${err.message}`);
+    log(
+      `[release-summary] fetch origin/${sourceBranch} failed: ${err.message}`,
+    );
     return [];
   }
 
   let untilArgs = '';
   try {
     const iso = git(`show -s --format=%cI ${to}`).trim();
-    if (iso) untilArgs = ` --until=${shellQuote(iso)}`;
+    if (iso) {
+      untilArgs = ` --until=${shellQuote(iso)}`;
+    }
   } catch {
     // optional
   }
@@ -75,19 +91,26 @@ export function getCommitsFromSourceBranch(from, to, sourceBranch) {
     );
     return raw.trim().split('\n').filter(Boolean);
   } catch (err) {
-    log(`[release-summary] git log ${from}..origin/${sourceBranch} failed: ${err.message}`);
+    log(
+      `[release-summary] git log ${from}..origin/${sourceBranch} failed: ${err.message}`,
+    );
     return [];
   }
 }
 
 export function getChangedPathsSummary(from, to) {
-  if (!from || from === '0000000000000000000000000000000000000000') return '';
+  if (!from || from === '0000000000000000000000000000000000000000') {
+    return '';
+  }
   try {
     const raw = git(`diff --name-status --diff-filter=ACMR ${from}...${to}`);
     const lines = raw.trim().split('\n').filter(Boolean);
-    if (!lines.length) return '';
+    if (!lines.length) {
+      return '';
+    }
     const shown = lines.slice(0, 80);
-    const suffix = lines.length > 80 ? `\n…and ${lines.length - 80} more paths` : '';
+    const suffix =
+      lines.length > 80 ? `\n…and ${lines.length - 80} more paths` : '';
     return `${shown.join('\n')}${suffix}`;
   } catch {
     return '';
@@ -98,23 +121,32 @@ function fallbackMessage(project, branch, commits) {
   const header = `:rocket: *${project}* deployed to *${branch}*`;
   const useful = filterNoiseCommits(commits);
   const list = useful.length ? useful : commits;
-  if (!list.length) return header;
-  const bullets = list.slice(0, 10).map((c) => `• ${escapeSlack(c)}`).join('\n');
+  if (!list.length) {
+    return header;
+  }
+  const bullets = list
+    .slice(0, 10)
+    .map(c => `• ${escapeSlack(c)}`)
+    .join('\n');
   const suffix = list.length > 10 ? `\n_…and ${list.length - 10} more_` : '';
   return `${header}\n\n${bullets}${suffix}`;
 }
 
 async function getAccessToken(credentials) {
   const now = Math.floor(Date.now() / 1000);
-  const header = Buffer.from(JSON.stringify({ alg: 'RS256', typ: 'JWT' })).toString('base64url');
-  const payload = Buffer.from(JSON.stringify({
-    iss: credentials.client_email,
-    sub: credentials.client_email,
-    aud: 'https://oauth2.googleapis.com/token',
-    iat: now,
-    exp: now + 3600,
-    scope: 'https://www.googleapis.com/auth/cloud-platform',
-  })).toString('base64url');
+  const header = Buffer.from(
+    JSON.stringify({ alg: 'RS256', typ: 'JWT' }),
+  ).toString('base64url');
+  const payload = Buffer.from(
+    JSON.stringify({
+      aud: 'https://oauth2.googleapis.com/token',
+      exp: now + 3600,
+      iat: now,
+      iss: credentials.client_email,
+      scope: 'https://www.googleapis.com/auth/cloud-platform',
+      sub: credentials.client_email,
+    }),
+  ).toString('base64url');
 
   const sign = createSign('RSA-SHA256');
   sign.update(`${header}.${payload}`);
@@ -122,11 +154,13 @@ async function getAccessToken(credentials) {
   const jwt = `${header}.${payload}.${signature}`;
 
   const res = await fetch('https://oauth2.googleapis.com/token', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
     body: `grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer&assertion=${jwt}`,
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    method: 'POST',
   });
-  if (!res.ok) throw new Error(`Token exchange failed: ${res.status}`);
+  if (!res.ok) {
+    throw new Error(`Token exchange failed: ${res.status}`);
+  }
   const data = await res.json();
   return data.access_token;
 }
@@ -155,35 +189,39 @@ Rules:
 - If all commits are internal-only, write: "• Internal improvements and maintenance"
 - Do NOT include a header or footer — just the bullet points
 - Do NOT use Slack formatting like *bold* — plain text only
-- Ignore generic release titles like "release: deploy develop to production"
+- Ignore generic release titles like "release: deploy main to production"
 
 Commits:
 ${commitList}${pathsBlock}`;
 
   const body = {
-    contents: [{ role: 'user', parts: [{ text: prompt }] }],
+    contents: [{ parts: [{ text: prompt }], role: 'user' }],
     generationConfig: {
-      temperature: 0.3,
       maxOutputTokens: 1024,
-      topP: 0.8,
+      temperature: 0.3,
       thinkingConfig: { thinkingBudget: 0 },
+      topP: 0.8,
     },
   };
 
   const res = await fetch(endpoint, {
-    method: 'POST',
+    body: JSON.stringify(body),
     headers: {
       Authorization: `Bearer ${accessToken}`,
       'Content-Type': 'application/json',
     },
-    body: JSON.stringify(body),
+    method: 'POST',
     signal: AbortSignal.timeout(15_000),
   });
 
-  if (!res.ok) throw new Error(`Gemini API error: ${res.status}`);
+  if (!res.ok) {
+    throw new Error(`Gemini API error: ${res.status}`);
+  }
   const data = await res.json();
   const text = data?.candidates?.[0]?.content?.parts?.[0]?.text;
-  if (!text) throw new Error('Empty Gemini response');
+  if (!text) {
+    throw new Error('Empty Gemini response');
+  }
   return text.trim();
 }
 
@@ -198,19 +236,25 @@ export async function releaseSummary() {
   const toSha = env('CI_COMMIT_SHA', 'HEAD');
   const branch = env('CI_COMMIT_REF_NAME', 'unknown');
   const project = env('CI_PROJECT_NAME', 'app');
-  const sourceBranch = env('RELEASE_SUMMARY_SOURCE_BRANCH', 'develop');
+  const sourceBranch = env('RELEASE_SUMMARY_SOURCE_BRANCH', 'main');
   const googleCreds = env('GOOGLE_CREDENTIALS_JSON');
 
   let commits = getCommitsInRange(fromSha, toSha);
 
   if (shouldResolveFromSourceBranch(commits)) {
-    log(`[release-summary] squash release detected; resolving via origin/${sourceBranch}`);
+    log(
+      `[release-summary] squash release detected; resolving via origin/${sourceBranch}`,
+    );
     const fromSource = getCommitsFromSourceBranch(fromSha, toSha, sourceBranch);
-    if (fromSource.length) commits = fromSource;
+    if (fromSource.length) {
+      commits = fromSource;
+    }
   }
 
   const filtered = filterNoiseCommits(commits);
-  if (filtered.length) commits = filtered;
+  if (filtered.length) {
+    commits = filtered;
+  }
 
   log(`[release-summary] resolved ${commits.length} commit(s)`);