shakers-cli-beta 0.8.0-beta.0

package/src/find-projects-cache.js

@@ -0,0 +1,89 @@
+'use strict';
+
+// Ordinal -> positionId cache for the LAST human `find-projects` listing, so the
+// terminal user can reference a project by the `N)` number they saw (the
+// positionId is hidden from the human render). Written only on a human list,
+// never on --json. Atomic 0600, same dir/style as the session store.
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { getConfigDir } = require('./config-dir');
+
+const CACHE_FILE_NAME = 'find-projects-cache.json';
+const CACHE_FILE_VERSION = 1;
+
+function cachePath(env = process.env) {
+  // Containment guard: the file name is a constant with no separators, so this
+  // can never escape — but resolving + checking closes the path-traversal gate
+  // cheaply and makes the invariant explicit. Throws on any escape; callers that
+  // read swallow it (return null), callers that write propagate (best-effort).
+  const base = path.resolve(getConfigDir(env));
+  const target = path.resolve(base, CACHE_FILE_NAME);
+  const rel = path.relative(base, target);
+  if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) {
+    throw new Error('find-projects cache path escapes the config dir');
+  }
+  return target;
+}
+
+// Persists the display-ordered positionIds (index i -> ordinal i+1).
+function writePositionCache(ids, env = process.env, { fs: fsImpl = fs } = {}) {
+  const clean = (Array.isArray(ids) ? ids : []).filter((id) => typeof id === 'string' && id);
+  const payload = `${JSON.stringify({ version: CACHE_FILE_VERSION, listedAt: new Date().toISOString(), ids: clean }, null, 2)}\n`;
+  const target = cachePath(env);
+  const dir = path.dirname(target);
+  fsImpl.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const tmp = path.join(dir, `.${CACHE_FILE_NAME}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  let fd = null;
+  try {
+    fd = fsImpl.openSync(tmp, 'wx', 0o600);
+    fsImpl.writeFileSync(fd, payload);
+    try { fsImpl.fsyncSync(fd); } catch { /* e.g. EINVAL on some filesystems */ }
+    fsImpl.closeSync(fd);
+    fd = null;
+    fsImpl.renameSync(tmp, target);
+  } catch (e) {
+    if (fd !== null) { try { fsImpl.closeSync(fd); } catch { /* already closed */ } }
+    try { fsImpl.unlinkSync(tmp); } catch { /* never existed */ }
+    throw e;
+  }
+  return target;
+}
+
+// Returns the stored id list, or null when there is no usable cache.
+function readPositionCache(env = process.env, { fs: fsImpl = fs } = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fsImpl.readFileSync(cachePath(env), 'utf8'));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== 'object' || parsed.version !== CACHE_FILE_VERSION || !Array.isArray(parsed.ids)) return null;
+  const ids = parsed.ids.filter((id) => typeof id === 'string' && id);
+  return { ids };
+}
+
+// Resolves a raw positional argument to a positionId. A PURE integer is an
+// ordinal into the last listing's cache; anything else (UUID / legacy Mongo id)
+// is passed through unchanged. Never resolves to the wrong project silently.
+function resolvePositionRef(raw, env = process.env, deps = {}) {
+  const read = deps.readPositionCache || readPositionCache;
+  const arg = typeof raw === 'string' ? raw.trim() : '';
+  if (!arg) return { ok: false, reason: 'no-id' };
+  if (!/^\d+$/.test(arg)) return { ok: true, id: arg }; // UUID / Mongo id passthrough
+  const n = Number.parseInt(arg, 10);
+  const cache = read(env);
+  if (!cache || cache.ids.length === 0) return { ok: false, reason: 'no-cache' };
+  if (n < 1 || n > cache.ids.length) return { ok: false, reason: 'out-of-range', count: cache.ids.length };
+  return { ok: true, id: cache.ids[n - 1] };
+}
+
+module.exports = {
+  CACHE_FILE_NAME,
+  CACHE_FILE_VERSION,
+  cachePath,
+  writePositionCache,
+  readPositionCache,
+  resolvePositionRef,
+};

package/src/find-projects-client.js

@@ -0,0 +1,138 @@
+'use strict';
+
+// Find Positions list client (hub `works/positions/find`, talent Bearer). Each
+// item carries the parent Project's id/name — a "project" here is the Position's
+// parent, not a separate list. Pagination (limit/offset) and filters map to the
+// endpoint's `criteria`; the server orders by match desc and returns the total.
+
+const { postJsonWithTimeout } = require('./backend-request');
+const { reasonForError } = require('./onboarding-client');
+
+const DEFAULT_TIMEOUT_MS = 20000;
+const DEFAULT_LIMIT = 15;
+// Only tabs the endpoint distinguishes server-side: All (default order) and
+// Saved (savedByMe). "Recommended" was a client illusion — dropped under
+// pagination, where it would only cover the fetched page and mislead.
+const TABS = ['all', 'saved'];
+const ATTENDANCE = { remote: 'REMOTE', hybrid: 'HYBRID', 'in-person': 'IN_PERSON' };
+
+function parseJson(raw) {
+  try {
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+function bearerHeaders(accessToken) {
+  const headers = {};
+  if (typeof accessToken === 'string' && accessToken) headers.Authorization = `Bearer ${accessToken}`;
+  return headers;
+}
+
+function pick(obj, keys) {
+  for (const k of keys) {
+    const v = obj && obj[k];
+    if (v !== undefined && v !== null && v !== '') return v;
+  }
+  return null;
+}
+
+function numOrNull(v) {
+  return typeof v === 'number' && Number.isFinite(v) ? v : null;
+}
+
+function strArray(v) {
+  return Array.isArray(v) ? v.filter((x) => typeof x === 'string' && x) : [];
+}
+
+// Only fields the readview's criteria map supports server-side: savedByMe,
+// attendance, country (confirmed in FindPositionsService + its prisma readview).
+// languages and skills are output-only (no filter field) → not built here.
+function buildCriteria(tab, { limit = DEFAULT_LIMIT, offset = 0, attendance = null, country = null } = {}) {
+  const criteria = { limit, offset };
+  const conditions = [];
+  if (tab === 'saved') conditions.push({ field: 'savedByMe', operator: 'EQUALS', value: true });
+  if (attendance) conditions.push({ field: 'attendance', operator: 'IN', value: [attendance] });
+  if (country) conditions.push({ field: 'country', operator: 'IN', value: [country] });
+  if (conditions.length) criteria.filter = { conjunction: 'AND', conditions };
+  return criteria;
+}
+
+function normalizeItem(raw) {
+  const it = raw && typeof raw === 'object' ? raw : {};
+  const company = it.company && typeof it.company === 'object' ? it.company : {};
+  const budget = it.budget && typeof it.budget === 'object' ? it.budget : null;
+  return {
+    positionId: pick(it, ['positionId', 'id']),
+    title: pick(it, ['title']),
+    projectId: pick(it, ['projectId']),
+    projectName: pick(it, ['projectName']),
+    description: pick(it, ['description']),
+    country: pick(it, ['country']),
+    requiredMonthlyHours: numOrNull(it.requiredMonthlyHours),
+    attendance: pick(it, ['attendance']),
+    match: numOrNull(it.match),
+    isSaved: it.isSaved === true,
+    company: {
+      name: pick(company, ['name']),
+      restricted: company.restricted === true,
+    },
+    budget: budget
+      ? {
+        from: numOrNull(budget.from),
+        to: numOrNull(budget.to),
+        unit: pick(budget, ['unit']),
+        display: pick(budget, ['display']),
+      }
+      : null,
+    skillNames: strArray(it.skillNames),
+    languages: strArray(it.languages),
+  };
+}
+
+async function requestFindProjects(
+  { hubAccessToken } = {},
+  { tab = 'all', endpoint, timeoutMs = DEFAULT_TIMEOUT_MS, limit = DEFAULT_LIMIT, offset = 0, attendance = null, country = null } = {},
+) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!hubAccessToken) return { ok: false, reason: 'no-hub-token' };
+
+  const criteria = buildCriteria(tab, { limit, offset, attendance, country });
+  const url = `${endpoint}${endpoint.includes('?') ? '&' : '?'}criteria=${encodeURIComponent(JSON.stringify(criteria))}`;
+  let res;
+  try {
+    res = await postJsonWithTimeout(url, null, timeoutMs, 'GET', null, bearerHeaders(hubAccessToken));
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+  if (res.status < 200 || res.status >= 300) return { ok: false, reason: reasonForError(res.status, res.raw) };
+
+  const env = parseJson(res.raw);
+  if (!env || typeof env !== 'object') return { ok: false, reason: 'bad-response' };
+  const data = env.status === 'OK' ? env.data : env;
+  const rows = Array.isArray(data) ? data : (Array.isArray(data && data.items) ? data.items : null);
+  if (!rows) return { ok: false, reason: 'bad-response' };
+  return { ok: true, items: rows.map(normalizeItem), meta: (env && typeof env.meta === 'object' ? env.meta : null) };
+}
+
+// CLI+MCP entry: resolve the endpoint from config, then fetch one page.
+async function fetchFindProjects(deps = {}, { hubAccessToken, tab = 'all', timeoutMs = DEFAULT_TIMEOUT_MS, limit = DEFAULT_LIMIT, offset = 0, attendance = null, country = null } = {}) {
+  const {
+    getFindPositionsEndpoint = require('./config').getFindPositionsEndpoint,
+    requestFindProjects: request = requestFindProjects,
+  } = deps;
+  const endpoint = getFindPositionsEndpoint();
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  return request({ hubAccessToken }, { tab, endpoint, timeoutMs, limit, offset, attendance, country });
+}
+
+module.exports = {
+  TABS,
+  ATTENDANCE,
+  DEFAULT_LIMIT,
+  buildCriteria,
+  normalizeItem,
+  requestFindProjects,
+  fetchFindProjects,
+};

package/src/find-projects-flow.js

@@ -0,0 +1,164 @@
+'use strict';
+
+// `find-projects` flow: list the Positions/Projects available to the talent,
+// paginated and filtered server-side via the endpoint's `criteria`. Read-only.
+
+const { TABS, ATTENDANCE, DEFAULT_LIMIT } = require('./find-projects-client');
+const { styleLabelPrefix } = require('./ansi');
+
+function makeFindProjectsDeps(overrides = {}) {
+  const client = require('./find-projects-client');
+  return {
+    fetchFindProjects: (opts) => client.fetchFindProjects({}, opts),
+    writePositionCache: (ids) => require('./find-projects-cache').writePositionCache(ids),
+    ...overrides,
+  };
+}
+
+// Normalize CLI/agent inputs to the shapes the endpoint's criteria expects.
+function resolveQuery(opts = {}) {
+  const tab = TABS.includes(opts.tab) ? opts.tab : 'all';
+  const limit = Number.isInteger(opts.limit) && opts.limit > 0 ? Math.min(opts.limit, 50) : DEFAULT_LIMIT;
+  const page = Number.isInteger(opts.page) && opts.page > 0 ? opts.page : 1;
+  const offset = (page - 1) * limit;
+  const attRaw = typeof opts.attendance === 'string' ? opts.attendance.trim().toLowerCase() : null;
+  const attendance = attRaw && ATTENDANCE[attRaw] ? ATTENDANCE[attRaw] : null;
+  const attendanceInvalid = !!(attRaw && !ATTENDANCE[attRaw]);
+  const countryRaw = typeof opts.country === 'string' ? opts.country.trim().toUpperCase() : null;
+  const country = countryRaw && /^[A-Z]{2}$/.test(countryRaw) ? countryRaw : null;
+  const countryInvalid = !!(countryRaw && !/^[A-Z]{2}$/.test(countryRaw));
+  return { tab, limit, page, offset, attendance, country, attendanceInvalid, countryInvalid, recommended: !!opts.recommended };
+}
+
+// `--recommended` is a CLIENT-SIDE filter over the fetched page (the hub has no
+// server-side "recommended" criterion — `match` is output-only). Recommended =
+// items that have a match. If none on this page, fall back to the available
+// items so the user is never left with an empty screen.
+function splitRecommended(items, recommended) {
+  if (!recommended) return { shown: items, mode: null };
+  const rec = items.filter((it) => it.match != null);
+  if (rec.length > 0) return { shown: rec, mode: 'recommended' };
+  return { shown: items, mode: 'fallback' };
+}
+
+function budgetLine(item, fp) {
+  if (item.budget && item.budget.display) return item.budget.display;
+  if (item.budget && (item.budget.from != null || item.budget.to != null)) {
+    return `${item.budget.from ?? '·'}–${item.budget.to ?? '·'}${item.budget.unit ? ` ${item.budget.unit}` : ''}`;
+  }
+  return fp.budgetUnknown;
+}
+
+function formatItem(item, index, fp) {
+  const headline = item.title || item.projectName || fp.untitled;
+  const company = item.company && item.company.name
+    ? item.company.name
+    : (item.company && item.company.restricted ? fp.companyRestricted : null);
+  // No type segment (positions-only, always "position" → redundant).
+  const metaBits = [
+    item.attendance || null,
+    item.country || null,
+    item.requiredMonthlyHours != null ? fp.hoursPerMonth(item.requiredMonthlyHours) : null,
+    budgetLine(item, fp),
+    item.match != null ? fp.matchScore(item.match) : null,
+    item.isSaved ? fp.savedBadge : null,
+  ].filter(Boolean);
+  // Human render never prints positionId/projectId (they stay in --json only).
+  const lines = [`${index}) ${headline}${company ? ` — ${company}` : ''}`];
+  if (item.projectName && item.projectName !== headline) lines.push(`   ${styleLabelPrefix(fp.projectLabel(item.projectName))}`);
+  lines.push(`   ${metaBits.join(' · ')}`);
+  return lines.join('\n  ');
+}
+
+// "Showing X–Y of TOTAL" (+ a next-page hint while more pages remain).
+function paginationFooter(fp, meta, q, shown) {
+  if (!meta || typeof meta.total !== 'number') return null;
+  if (meta.total === 0) return null;
+  const from = q.offset + 1;
+  const to = q.offset + shown;
+  let line = fp.showing(from, to, meta.total);
+  if (meta.totalPages && q.page < meta.totalPages) line += ` · ${fp.morePages(q.page + 1)}`;
+  return line;
+}
+
+// Honest footer while showing the client-side recommended SUBSET of a page:
+// never "X of TOTAL" (TOTAL is all available, not recommended). Pagination still
+// works to pull more pages (which may carry more recommended).
+function recommendedFooter(fp, count, meta, q) {
+  let line = fp.recommendedOnPage(count);
+  if (meta && meta.totalPages && q.page < meta.totalPages) line += ` · ${fp.morePages(q.page + 1)}`;
+  return line;
+}
+
+async function runFindProjects({ io, rawOut, session, lang, catalog, opts = {}, deps = makeFindProjectsDeps() }) {
+  const fp = catalog.findProjects;
+  const hubAccessToken = session ? session.hubAccessToken : null;
+  const q = resolveQuery(opts);
+
+  if (!opts.json) {
+    if (q.attendanceInvalid) io.warn(fp.attendanceIgnored);
+    if (q.countryInvalid) io.warn(fp.countryIgnored);
+  }
+
+  // In --json the loading label must not print (it would corrupt the JSON on a
+  // non-TTY stdout); only decorate the human path with the progress spinner.
+  const fetchPage = () => deps.fetchFindProjects({
+    hubAccessToken, tab: q.tab, limit: q.limit, offset: q.offset, attendance: q.attendance, country: q.country,
+  });
+  const res = opts.json ? await fetchPage() : await io.withProgress(fp.loading, fetchPage);
+  if (!res.ok) {
+    io.error(fp.fetchFailed(res.reason));
+    return { ok: false, reason: res.reason };
+  }
+
+  const items = Array.isArray(res.items) ? res.items : [];
+  // Client-side recommended filter (+ fallback to available), applied to both
+  // the human render and --json so an agent sees the same view (json keeps match).
+  const { shown, mode } = splitRecommended(items, q.recommended);
+
+  if (opts.json) {
+    (rawOut || ((s) => process.stdout.write(s)))(`${JSON.stringify({
+      ok: true,
+      tab: q.tab,
+      page: q.page,
+      limit: q.limit,
+      filters: { attendance: q.attendance, country: q.country, recommended: q.recommended },
+      recommended: mode,
+      meta: res.meta || null,
+      items: shown,
+    }, null, 2)}\n`);
+    return { ok: true, items: shown, meta: res.meta || null, recommended: mode };
+  }
+
+  // Persist the ordinal -> positionId map of what is SHOWN so `show-project N`
+  // matches the render. Human path only; a write failure never breaks the listing.
+  try { deps.writePositionCache(shown.map((it) => it.positionId)); } catch { /* cache is best-effort */ }
+
+  io.section(q.tab === 'saved' ? fp.titleSaved : fp.title);
+  if (items.length === 0) {
+    io.notify(q.page > 1 ? fp.noneOnPage : fp.noneAvailable);
+    return { ok: true, items: shown, meta: res.meta || null, recommended: mode };
+  }
+  // No recommended on this page -> we show the available ones, with a clear notice.
+  if (mode === 'fallback') io.notify(fp.recommendedNoneFallback);
+  shown.forEach((item, i) => {
+    if (i > 0) io.notify('');
+    io.notify(formatItem(item, i + 1, fp));
+  });
+  const footer = mode === 'recommended'
+    ? recommendedFooter(fp, shown.length, res.meta, q)
+    : paginationFooter(fp, res.meta, q, shown.length);
+  if (footer) io.notify(footer);
+  io.success(fp.done);
+  return { ok: true, items: shown, meta: res.meta || null, recommended: mode };
+}
+
+module.exports = {
+  makeFindProjectsDeps,
+  runFindProjects,
+  resolveQuery,
+  splitRecommended,
+  formatItem,
+  paginationFooter,
+  recommendedFooter,
+};

package/src/git-activity.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+
+const GIT_TIMEOUT_MS = 15000;
+const MAX_FILE_TYPES = 50;
+
+function runGit(root, args) {
+  try {
+    return execFileSync('git', ['-C', root, ...args], {
+      encoding: 'utf8',
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      maxBuffer: 64 * 1024 * 1024,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function isGitRepo(root) {
+  return runGit(root, ['rev-parse', '--is-inside-work-tree']) !== null;
+}
+
+function extensionOf(rawPath) {
+  let p = rawPath;
+  const arrow = p.indexOf('=>');
+  if (arrow !== -1) {
+    p = p
+      .slice(arrow + 2)
+      .replace(/[{}]/g, '')
+      .trim();
+  }
+  const base = path.basename(p.trim());
+  const ext = path.extname(base).replace(/^\./, '').toLowerCase();
+  return ext || 'none';
+}
+
+function bumpFileType(filesByType, ext) {
+  if (Object.prototype.hasOwnProperty.call(filesByType, ext)) {
+    filesByType[ext] += 1;
+    return;
+  }
+  if (Object.keys(filesByType).length >= MAX_FILE_TYPES) return;
+  filesByType[ext] = 1;
+}
+
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+
+// Deterministic git-activity signals for the project where `shakers ai-usage` runs (hybrid evaluation, Slice 1).
+function collectGitActivity(root, verifiedEmail) {
+  if (!isGitRepo(root)) return null;
+
+  const sep = String.fromCharCode(1);
+  const unit = String.fromCharCode(31);
+  const log = runGit(root, [
+    'log',
+    '--no-merges',
+    '--numstat',
+    `--pretty=format:${sep}%ae${unit}%at`,
+  ]);
+  if (log === null) return null;
+
+  const target = String(verifiedEmail || '')
+    .trim()
+    .toLowerCase();
+
+  let commitCount = 0;
+  let authoredCommitCount = 0;
+  let linesAdded = 0;
+  let linesDeleted = 0;
+  let minTs = null;
+  let maxTs = null;
+  const filesByType = {};
+
+  for (const rawLine of log.split('\n')) {
+    if (rawLine.startsWith(sep)) {
+      commitCount += 1;
+      const [email, atRaw] = rawLine.slice(1).split(unit);
+      if (target && String(email || '').trim().toLowerCase() === target) {
+        authoredCommitCount += 1;
+      }
+      const ts = Number.parseInt(atRaw, 10);
+      if (Number.isFinite(ts)) {
+        if (minTs === null || ts < minTs) minTs = ts;
+        if (maxTs === null || ts > maxTs) maxTs = ts;
+      }
+      continue;
+    }
+    const line = rawLine.trim();
+    if (!line) continue;
+    const parts = line.split('\t');
+    if (parts.length < 3) continue;
+    const [addedRaw, deletedRaw] = parts;
+    const filePath = parts.slice(2).join('\t');
+    if (addedRaw !== '-') linesAdded += Number.parseInt(addedRaw, 10) || 0;
+    if (deletedRaw !== '-') linesDeleted += Number.parseInt(deletedRaw, 10) || 0;
+    bumpFileType(filesByType, extensionOf(filePath));
+  }
+
+  if (commitCount === 0) return null;
+
+  const spanDays =
+    minTs !== null && maxTs !== null
+      ? Math.max(0, Math.floor((maxTs - minTs) / 86400))
+      : 0;
+  const velocity = round2(commitCount / Math.max(spanDays, 1));
+
+  return {
+    commitCount,
+    authoredCommitCount,
+    linesAdded,
+    linesDeleted,
+    filesByType,
+    velocity,
+    spanDays,
+  };
+}
+
+module.exports = { collectGitActivity, extensionOf, isGitRepo };

package/src/graph-certs.js

@@ -0,0 +1,58 @@
+'use strict';
+
+// graph-certs.js — report-store → `map` cert-drawer payload adapter.
+
+const { getCatalog } = require('./i18n');
+const { scoreBand, skillLevelForScore } = require('./render-certification');
+const { sanitizeRenderText } = require('./sanitize-network-text');
+
+function levelInfoFromCombinedLevel(combinedLevel) {
+  const key = typeof combinedLevel === 'string' ? combinedLevel.trim().toLowerCase() : '';
+  if (key === 'expert') return { key: 'expert', band: 'high' };
+  if (key === 'senior') return { key: 'senior', band: 'mid' };
+  if (key === 'middle') return { key: 'middle', band: 'low' };
+  return null;
+}
+
+// buildCertsPayload(project, lang) -> cert drawer payload | null `project` is a report-store project entry (state.projects[absRoot]).
+function buildCertsPayload(project, lang) {
+  const t = getCatalog(lang);
+
+  const certObj = (project && project.certifications) || {};
+  const skills = Object.values(certObj)
+    .map((e) => e && e.item)
+    .filter(Boolean)
+    .map((item) => {
+      const res = item.result || {};
+      // `skillName` and `technology` both come off the wire (the service's certifiable list / verdict), and `technology` was one of the two fields issue 055 was opened for.
+      const base = sanitizeRenderText(item.skillName) || (item.skillId != null ? String(item.skillId) : 'Skill');
+      const name = item.technology ? `${base} · ${sanitizeRenderText(item.technology)}` : base;
+      // ADR-016: named level (Middle/Senior/Expert) instead of the numeric grade.
+      const skillReport = (t.certify && t.certify.report) || {};
+      const skillLevelNames = skillReport.skillLevels || {};
+      const { key: levelKey, band } = levelInfoFromCombinedLevel(res.combinedLevel) || skillLevelForScore(res.score);
+      return {
+        name,
+        band, // retained for the badge colour (unchanged palette)
+        levelKey,
+        levelName: levelKey ? (skillLevelNames[levelKey] || levelKey) : (skillLevelNames.na || '—'),
+        // Model-written text off the wire; sanitised (issue 055 — left raw by 052).
+        rationale: typeof res.rationale === 'string' ? sanitizeRenderText(res.rationale) : '',
+        improvements: Array.isArray(res.improvements)
+          ? res.improvements.map((i) => (typeof i === 'string' ? sanitizeRenderText(i) : i))
+          : [],
+      };
+    });
+
+  if (!skills.length) return null;
+
+  const labels = {
+    skillsTitle: lang === 'es' ? 'Skills evaluadas' : 'Skills evaluated',
+    empty: lang === 'es' ? 'Aún no hay certificaciones para este proyecto.' : 'No certifications for this project yet.',
+    improvements: lang === 'es' ? 'Mejoras sugeridas' : 'Suggested improvements',
+  };
+
+  return { labels, skills };
+}
+
+module.exports = { buildCertsPayload, levelInfoFromCombinedLevel };