@hellopearl/dv-gitlab 0.4.2 → 0.4.4

package/ci/slack-deploy.yml

@@ -0,0 +1,35 @@
+# Reusable template: Slack deploy notification with release summary.
+# Generates an AI-powered summary of commits (falls back to bullet list).
+# Requires the `hellopearl/devops/cicd/common` slack-notify template.
+#
+# Consumer usage:
+#   include:
+#     - project: 'hellopearl/pearl-agentic-mono'
+#       ref: main
+#       file: '/packages/dev/dv-gitlab/ci/slack-deploy.yml'
+#     - project: 'hellopearl/devops/cicd/common'
+#       file: 'gitlab/slack-notify.yml'
+#
+#   notify:deploy:
+#     extends: .slack-deploy
+#     variables:
+#       SLACK_CHANNEL: "#deployments-rcm"
+
+.slack-deploy:
+  extends: .slack_notify
+  image: node:22-alpine
+  stage: post-deploy
+  needs: []
+  before_script:
+    - apk add --no-cache git
+    - 'export SLACK_MESSAGE=$(npx @hellopearl/dv-gitlab release-summary 2>/dev/null || echo ":rocket: *$CI_PROJECT_NAME* deployed to *$CI_COMMIT_REF_NAME*")'
+  variables:
+    SLACK_CHANNEL: "#deployments"
+    SLACK_MESSAGE: ":rocket: *$CI_PROJECT_NAME* deployed to *$CI_COMMIT_REF_NAME*"
+    GIT_DEPTH: 500
+    RELEASE_SUMMARY_SOURCE_BRANCH: develop
+  rules:
+    - if: $CI_COMMIT_BRANCH == "main"
+    - if: $CI_COMMIT_BRANCH == "prod"
+    - if: $CI_COMMIT_BRANCH == "stage"
+    - if: $CI_COMMIT_BRANCH == "sandbox"

package/ci/version-bump.yml

@@ -0,0 +1,61 @@
+# Reusable template: auto-bump patch version on develop merge.
+# Increments the patch version in package.json and pushes with [skip ci].
+#
+# Consumer usage:
+#   include:
+#     - project: 'hellopearl/pearl-agentic-mono'
+#       ref: main
+#       file: '/packages/dev/dv-gitlab/ci/version-bump.yml'
+#
+#   bump-version:
+#     extends: .version-bump
+
+.version-bump:
+  stage: post-deploy
+  image: node:22-alpine
+  variables:
+    GIT_STRATEGY: none
+    VERSION_BUMP_BRANCH: develop
+  before_script:
+    - apk add --no-cache git
+    - git config --global user.email "ci@hellopearl.com"
+    - git config --global user.name "GitLab CI"
+    - git clone --depth=1 -b "$VERSION_BUMP_BRANCH" "https://oauth2:${GITLAB_TOKEN}@gitlab.com/${CI_PROJECT_PATH}.git" repo
+    - cd repo
+  script:
+    - |
+      MAX_RETRIES=3
+      for i in $(seq 1 $MAX_RETRIES); do
+        git fetch origin "$VERSION_BUMP_BRANCH:refs/remotes/origin/$VERSION_BUMP_BRANCH"
+        git reset --hard "origin/$VERSION_BUMP_BRANCH"
+
+        CURRENT=$(node -p "require('./package.json').version")
+        MAJOR=$(echo "$CURRENT" | cut -d. -f1)
+        MINOR=$(echo "$CURRENT" | cut -d. -f2)
+        PATCH=$(echo "$CURRENT" | cut -d. -f3)
+        NEXT="${MAJOR}.${MINOR}.$((PATCH + 1))"
+
+        node -e "
+          const fs = require('fs');
+          const pkg = JSON.parse(fs.readFileSync('package.json','utf8'));
+          pkg.version = '${NEXT}';
+          fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
+        "
+
+        git add package.json
+        git commit -m "chore: bump version to ${NEXT} [skip ci]"
+
+        if git push origin "HEAD:$VERSION_BUMP_BRANCH"; then
+          echo "Bumped ${CURRENT} -> ${NEXT}"
+          exit 0
+        fi
+
+        echo "Push failed (attempt $i/$MAX_RETRIES), retrying..."
+        sleep 2
+      done
+
+      echo "Version bump failed after $MAX_RETRIES attempts — skipping"
+      exit 0
+  rules:
+    - if: $CI_COMMIT_BRANCH == $VERSION_BUMP_BRANCH
+      when: on_success

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellopearl/dv-gitlab",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Unified GitLab CI tooling -- MR comments, pipeline triggers, preview env management",
   "license": "UNLICENSED",
   "type": "module",
@@ -48,5 +48,5 @@
     "@hellopearl/dv-prettier": "*",
     "@hellopearl/dv-test": "*"
   },
-  "gitHead": "36acb7c5235796449a1425d8a8853f424c1bbb2a"
+  "gitHead": "954585e656b4cf6e6b89e294d14a97499c82c874"
 }

package/src/cli.mjs

@@ -1,6 +1,7 @@
 import { cleanupBranch } from './commands/cleanup-branch.mjs';
 import { postComment } from './commands/post-comment.mjs';
 import { postbuild } from './commands/postbuild.mjs';
+import { releaseSummary } from './commands/release-summary.mjs';
 import { triggerPipeline } from './commands/trigger-pipeline.mjs';
 import { validateToken } from './commands/validate-token.mjs';
 import { log } from './lib/logger.mjs';
@@ -9,6 +10,7 @@ const COMMANDS = {
   'cleanup-branch': cleanupBranch,
   'post-comment': postComment,
   postbuild,
+  'release-summary': releaseSummary,
   'trigger-pipeline': triggerPipeline,
   'validate-token': validateToken,
 };
@@ -45,6 +47,7 @@ Commands:
   trigger-pipeline   Trigger a GitLab CI pipeline
   validate-token     Check if a GitLab PAT is valid
   cleanup-branch     Delete an Amplify preview branch
+  release-summary    Generate Slack deploy summary from git commits (AI-powered with fallback)
 
 Options:
   --help             Show this help message

package/src/commands/postbuild.mjs

@@ -202,8 +202,11 @@ export async function postbuild() {
 
   const buildCandidates = [
     process.env.CODEBUILD_SRC_DIR && `${process.env.CODEBUILD_SRC_DIR}/build`,
+    process.env.CODEBUILD_SRC_DIR && `${process.env.CODEBUILD_SRC_DIR}/out`,
     'build',
+    'out',
     'dist',
+    '.next',
   ].filter(Boolean);
 
   let buildExists = false;

package/src/commands/release-summary.mjs

@@ -0,0 +1,248 @@
+import { execSync } from 'node:child_process';
+import { createSign } from 'node:crypto';
+import { log } from '../lib/logger.mjs';
+
+const MAX_COMMITS = 30;
+const NOISE_COMMIT_RE =
+  /^(release:|merge branch |merge remote-tracking |chore\(merge\)|hotfix\/)/i;
+
+function env(key, fallback = '') {
+  return process.env[key] || fallback;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function git(command) {
+  return execSync(`git ${command}`, {
+    encoding: 'utf8',
+    timeout: 60_000,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+}
+
+export function escapeSlack(text) {
+  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+export function isNoiseCommit(subject) {
+  return NOISE_COMMIT_RE.test(subject.trim());
+}
+
+export function filterNoiseCommits(commits) {
+  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()));
+}
+
+export function getCommitsInRange(from, to) {
+  if (!from || from === '0000000000000000000000000000000000000000') return [];
+  try {
+    const raw = git(`log ${from}..${to} --no-merges --format="%s"`);
+    return raw.trim().split('\n').filter(Boolean);
+  } catch (err) {
+    log(`[release-summary] git log ${from}..${to} failed: ${err.message}`);
+    return [];
+  }
+}
+
+export function getCommitsFromSourceBranch(from, to, sourceBranch) {
+  if (!from || from === '0000000000000000000000000000000000000000') return [];
+  try {
+    git(`fetch origin ${sourceBranch} --depth=500`);
+  } catch (err) {
+    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)}`;
+  } catch {
+    // optional
+  }
+
+  try {
+    const raw = git(
+      `log ${from}..origin/${sourceBranch} --no-merges --format="%s"${untilArgs}`,
+    );
+    return raw.trim().split('\n').filter(Boolean);
+  } catch (err) {
+    log(`[release-summary] git log ${from}..origin/${sourceBranch} failed: ${err.message}`);
+    return [];
+  }
+}
+
+export function getChangedPathsSummary(from, to) {
+  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 '';
+    const shown = lines.slice(0, 80);
+    const suffix = lines.length > 80 ? `\n…and ${lines.length - 80} more paths` : '';
+    return `${shown.join('\n')}${suffix}`;
+  } catch {
+    return '';
+  }
+}
+
+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');
+  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 sign = createSign('RSA-SHA256');
+  sign.update(`${header}.${payload}`);
+  const signature = sign.sign(credentials.private_key, 'base64url');
+  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}`,
+  });
+  if (!res.ok) throw new Error(`Token exchange failed: ${res.status}`);
+  const data = await res.json();
+  return data.access_token;
+}
+
+async function callGemini(accessToken, project, commits, changedPaths = '') {
+  const gcpProject = env('GOOGLE_CLOUD_PROJECT', 'voice-project-497618');
+  const gcpLocation = env('GOOGLE_CLOUD_LOCATION', 'us-central1');
+  const model = env('RELEASE_SUMMARY_MODEL', 'gemini-2.5-flash');
+  const endpoint = `https://${gcpLocation}-aiplatform.googleapis.com/v1/projects/${gcpProject}/locations/${gcpLocation}/publishers/google/models/${model}:generateContent`;
+
+  const commitList = commits.slice(0, MAX_COMMITS).join('\n');
+  const pathsBlock = changedPaths
+    ? `\n\nChanged paths (for context; do not list every file):\n${changedPaths}`
+    : '';
+
+  const prompt = `You are summarizing git commits for a ${project} deploy. Stay factual and close to what was actually done.
+
+Rules:
+- Group related commits into a single bullet point
+- Stay close to the actual change — don't embellish or generalize too much
+- Remove Jira ticket IDs (like SCRIBE-123, INS-456) but keep the substance
+- Remove prefixes like "fix:", "feat:", "refactor:" — just describe what was done
+- Skip commits that are purely internal (CI config, test infrastructure, dependency bumps, pure refactors with no behavior change)
+- Maximum 8 bullet points, each starting with •
+- Each bullet should be one concise line
+- 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"
+
+Commits:
+${commitList}${pathsBlock}`;
+
+  const body = {
+    contents: [{ role: 'user', parts: [{ text: prompt }] }],
+    generationConfig: {
+      temperature: 0.3,
+      maxOutputTokens: 1024,
+      topP: 0.8,
+      thinkingConfig: { thinkingBudget: 0 },
+    },
+  };
+
+  const res = await fetch(endpoint, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(15_000),
+  });
+
+  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');
+  return text.trim();
+}
+
+/**
+ * Generates a release summary for Slack deploy notifications.
+ * Reads commit range from GitLab CI env vars, optionally calls Gemini for
+ * AI-powered summary, falls back to a bullet list of commits.
+ * Outputs Slack mrkdwn to stdout.
+ */
+export async function releaseSummary() {
+  const fromSha = env('CI_COMMIT_BEFORE_SHA');
+  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 googleCreds = env('GOOGLE_CREDENTIALS_JSON');
+
+  let commits = getCommitsInRange(fromSha, toSha);
+
+  if (shouldResolveFromSourceBranch(commits)) {
+    log(`[release-summary] squash release detected; resolving via origin/${sourceBranch}`);
+    const fromSource = getCommitsFromSourceBranch(fromSha, toSha, sourceBranch);
+    if (fromSource.length) commits = fromSource;
+  }
+
+  const filtered = filterNoiseCommits(commits);
+  if (filtered.length) commits = filtered;
+
+  log(`[release-summary] resolved ${commits.length} commit(s)`);
+
+  if (!commits.length) {
+    process.stdout.write(fallbackMessage(project, branch, commits));
+    return;
+  }
+
+  if (!googleCreds) {
+    log('[release-summary] GOOGLE_CREDENTIALS_JSON missing; using fallback');
+    process.stdout.write(fallbackMessage(project, branch, commits));
+    return;
+  }
+
+  let credentials;
+  try {
+    credentials = JSON.parse(googleCreds);
+  } catch {
+    log('[release-summary] invalid GOOGLE_CREDENTIALS_JSON; using fallback');
+    process.stdout.write(fallbackMessage(project, branch, commits));
+    return;
+  }
+
+  const changedPaths = getChangedPathsSummary(fromSha, toSha);
+
+  try {
+    const token = await getAccessToken(credentials);
+    const summary = await callGemini(token, project, commits, changedPaths);
+    const header = `:rocket: *${project}* deployed to *${branch}*`;
+    process.stdout.write(`${header}\n\n${escapeSlack(summary)}`);
+  } catch (err) {
+    log(`[release-summary] Gemini failed; using fallback: ${err.message}`);
+    process.stdout.write(fallbackMessage(project, branch, commits));
+  }
+}