shakers-cli-beta 0.8.0-beta.0

package/src/signup-client.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const { postJsonWithTimeout, extractSetCookie } = require('./backend-request');
+const { SESSION_COOKIE_NAME } = require('./auth-client');
+const { toUpperLang } = require('./lang-codes');
+
+// Register a talent via the Hub's better-auth email engine, in two steps (owner decision, supersedes ADR-031 for the email path — WEB-login parity): 1.
+
+const DEFAULT_TIMEOUT_MS = 30000;
+
+function parseJson(raw) {
+  try { return raw ? JSON.parse(raw) : null; } catch { return null; }
+}
+
+function messageFrom(raw) {
+  const body = parseJson(raw);
+  if (!body || typeof body !== 'object') return null;
+  if (typeof body.message === 'string' && body.message) return body.message;
+  if (Array.isArray(body.message) && body.message.length) return body.message.join('; ');
+  return null;
+}
+
+function buildRegistrationContext({ preferredLanguage, newsletterConsent, freelanceType, freelanceIntent } = {}) {
+  const context = {};
+  if (typeof preferredLanguage === 'string' && preferredLanguage) context.preferredLanguage = toUpperLang(preferredLanguage);
+  context.newsletterConsent = newsletterConsent === true;
+  if (typeof freelanceType === 'string' && freelanceType) context.freelanceType = freelanceType;
+  if (typeof freelanceIntent === 'string' && freelanceIntent) context.freelanceIntent = freelanceIntent;
+  return context;
+}
+
+// Shared complete-registration call: authenticated by the email `cookie` or the device flow `bearerToken`.
+async function requestCompleteRegistration(
+  context = {},
+  { endpoint, cookie = null, bearerToken = null, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
+) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  const headers = {};
+  if (cookie) headers.Cookie = cookie;
+  if (bearerToken) headers.Authorization = `Bearer ${bearerToken}`;
+  let complete;
+  try {
+    complete = await postJsonWithTimeout(
+      endpoint,
+      { userType: 'WORKS_TALENT', context },
+      timeoutMs,
+      'POST',
+      null,
+      Object.keys(headers).length ? headers : null,
+    );
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+  if (complete.status < 200 || complete.status >= 300) {
+    return { ok: false, reason: `complete-registration-http-${complete.status}`, status: complete.status, message: messageFrom(complete.raw) };
+  }
+  return { ok: true };
+}
+
+async function requestSignUp(
+  { name, lastName, email, password, preferredLanguage, newsletterConsent, freelanceType, freelanceIntent } = {},
+  { signUpEndpoint, completeRegistrationEndpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {},
+) {
+  if (!signUpEndpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!name || !lastName || !email || !password) return { ok: false, reason: 'missing-fields' };
+
+  let signUp;
+  try {
+    signUp = await postJsonWithTimeout(signUpEndpoint, { email, password, name, lastName }, timeoutMs);
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+
+  // A duplicate email is a normal outcome the caller handles by switching to login.
+  if (signUp.status === 409 || signUp.status === 422) return { ok: true, accountExists: true };
+  if (signUp.status < 200 || signUp.status >= 300) {
+    return { ok: false, reason: `http-${signUp.status}`, status: signUp.status, message: messageFrom(signUp.raw) };
+  }
+
+  const cookie = extractSetCookie(signUp.headers, SESSION_COOKIE_NAME);
+  if (!cookie) return { ok: false, reason: 'bad-response' };
+
+  if (!completeRegistrationEndpoint) return { ok: false, reason: 'no-endpoint' };
+
+  const context = buildRegistrationContext({ preferredLanguage, newsletterConsent, freelanceType, freelanceIntent });
+  const complete = await requestCompleteRegistration(context, { endpoint: completeRegistrationEndpoint, cookie, timeoutMs });
+  if (!complete.ok) return complete;
+  return { ok: true, accountExists: false };
+}
+
+module.exports = { requestSignUp, requestCompleteRegistration, buildRegistrationContext };

package/src/skills-client.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const { postJsonWithTimeout } = require('./backend-request');
+
+// Talent-skills client (talents-ai-score, ADR-054/055 — `start`'s "Añadir skills" route, src/start-add-skills.js).
+
+const DEFAULT_TIMEOUT_MS = 20000;
+
+// `works.*` business codes (WorksExceptionFilter's `codeMap`) -> this client's own reason vocabulary.
+const WORKS_CODE_TO_REASON = {
+  'certification.dimension_on_cooldown': 'dimension-on-cooldown',
+  'interview.non_conversational_blocks_in_text': 'needs-web',
+  'works.hub_token_missing': 'no-hub-token',
+  'works.hub_session_expired': 'hub-session-expired',
+  'works.hub_upstream_error': 'hub-upstream-error',
+  'works.hub_unavailable': 'hub-unavailable',
+  'works.ai_consent_required': 'ai-consent-required',
+  'interview.already_started': 'interview-already-started',
+  'interview.onboarding_not_found': 'onboarding-not-found',
+  'assigned-clusters.already_assigned': 'already-assigned',
+  'assigned-clusters.cap_reached': 'role-cap-reached',
+  'assigned-clusters.invalid_cluster': 'invalid-cluster',
+  'assigned-clusters.not_assigned': 'not-assigned',
+};
+
+function parseJson(raw) {
+  try {
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+// The certs session Bearer (standard `AuthGuard`, required on ALL THREE talent-skills routes — none of them is `@Public()`) plus, only when present, the Talent's own Hub token.
+function authHeaders({ accessToken, hubAccessToken } = {}) {
+  const headers = {};
+  if (typeof accessToken === 'string' && accessToken) headers.Authorization = `Bearer ${accessToken}`;
+  if (typeof hubAccessToken === 'string' && hubAccessToken) headers['X-Hub-Token'] = hubAccessToken;
+  return headers;
+}
+
+function reasonForError(status, raw) {
+  const body = parseJson(raw);
+  const code = body && typeof body.code === 'string' ? body.code : null;
+  return (code && WORKS_CODE_TO_REASON[code]) || `http-${status}`;
+}
+
+// `POST .../skills/resolve-addable`.
+async function requestResolveAddableSkills({ technologies, accessToken } = {}, { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+
+  const body = { technologies: Array.isArray(technologies) ? technologies.filter((t) => typeof t === 'string' && t) : [] };
+  let res;
+  try {
+    res = await postJsonWithTimeout(endpoint, body, timeoutMs, 'POST', null, authHeaders({ accessToken }));
+  } 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 json = parseJson(res.raw);
+  const data = json && typeof json === 'object' && Array.isArray(json.data) ? json.data : null;
+  if (!data) return { ok: false, reason: 'bad-response' };
+
+  const addable = data
+    .map((entry) => ({
+      skillId: entry && typeof entry.skillId === 'number' ? entry.skillId : null,
+      skillName: entry && typeof entry.skillName === 'string' ? entry.skillName : null,
+      technology: entry && typeof entry.technology === 'string' ? entry.technology : null,
+    }))
+    .filter((s) => s.skillId !== null);
+  return { ok: true, addable };
+}
+
+// `POST .../skills/declare`.
+async function requestDeclareSkill({ skillId, accessToken, hubAccessToken } = {}, { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!hubAccessToken) return { ok: false, reason: 'no-hub-token' };
+
+  let res;
+  try {
+    res = await postJsonWithTimeout(endpoint, { skillId }, timeoutMs, 'POST', null, authHeaders({ accessToken, hubAccessToken }));
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+
+  if (res.status < 200 || res.status >= 300) {
+    if (res.status === 409) return { ok: false, reason: 'skill-exists' };
+    return { ok: false, reason: reasonForError(res.status, res.raw) };
+  }
+
+  const json = parseJson(res.raw);
+  if (!json || json.status !== 'OK' || !Array.isArray(json.data)) {
+    return { ok: false, reason: 'bad-response' };
+  }
+  return { ok: true };
+}
+
+module.exports = { requestResolveAddableSkills, requestDeclareSkill, reasonForError, WORKS_CODE_TO_REASON };

package/src/socials-client.js

@@ -0,0 +1,91 @@
+'use strict';
+
+// Social links client. VIEW = GET `works/me/social`; SET = PUT the same endpoint
+// (upsert of the WHOLE object — a fixed set of named URL fields, not per-link rows).
+
+const { postJsonWithTimeout } = require('./backend-request');
+const { reasonForError } = require('./onboarding-client');
+
+const DEFAULT_TIMEOUT_MS = 20000;
+const NETWORKS = ['linkedin', 'github', 'website', 'twitter', 'instagram', 'facebook', 'dribbble', 'behance'];
+
+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 normalizeSocial(data) {
+  const it = data && typeof data === 'object' ? data : {};
+  const out = {};
+  for (const k of NETWORKS) out[k] = typeof it[k] === 'string' && it[k] ? it[k] : null;
+  return out;
+}
+
+async function requestSocials({ hubAccessToken } = {}, { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!hubAccessToken) return { ok: false, reason: 'no-hub-token' };
+  let res;
+  try {
+    res = await postJsonWithTimeout(endpoint, null, timeoutMs, 'GET', null, bearerHeaders(hubAccessToken));
+  } catch (e) {
+    return { ok: false, reason: (e && e.kind) || 'network-error' };
+  }
+  // No social section yet is a normal empty state, not an error.
+  if (res.status === 404) return { ok: true, social: normalizeSocial({}) };
+  if (res.status < 200 || res.status >= 300) return { ok: false, reason: reasonForError(res.status, res.raw) };
+  const env = parseJson(res.raw);
+  const data = env && env.status === 'OK' ? env.data : env;
+  if (!data || typeof data !== 'object') return { ok: false, reason: 'bad-response' };
+  return { ok: true, social: normalizeSocial(data) };
+}
+
+// Upsert the WHOLE object: `social` carries every network (value or null).
+async function requestSetSocials({ hubAccessToken, social } = {}, { endpoint, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  if (!hubAccessToken) return { ok: false, reason: 'no-hub-token' };
+  if (!social || typeof social !== 'object') return { ok: false, reason: 'no-social' };
+  const body = {};
+  for (const k of NETWORKS) body[k] = typeof social[k] === 'string' && social[k] ? social[k] : null;
+  let res;
+  try {
+    res = await postJsonWithTimeout(endpoint, body, timeoutMs, 'PUT', 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) };
+  return { ok: true };
+}
+
+async function fetchSocials(deps = {}, { hubAccessToken, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const getEndpoint = deps.getMeSocialEndpoint || require('./config').getMeSocialEndpoint;
+  const request = deps.requestSocials || requestSocials;
+  const endpoint = getEndpoint();
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  return request({ hubAccessToken }, { endpoint, timeoutMs });
+}
+
+async function saveSocials(deps = {}, { hubAccessToken, social, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+  const getEndpoint = deps.getMeSocialEndpoint || require('./config').getMeSocialEndpoint;
+  const request = deps.requestSetSocials || requestSetSocials;
+  const endpoint = getEndpoint();
+  if (!endpoint) return { ok: false, reason: 'no-endpoint' };
+  return request({ hubAccessToken, social }, { endpoint, timeoutMs });
+}
+
+module.exports = {
+  NETWORKS,
+  normalizeSocial,
+  requestSocials,
+  requestSetSocials,
+  fetchSocials,
+  saveSocials,
+};

package/src/socials-flow.js

@@ -0,0 +1,83 @@
+'use strict';
+
+// `socials` flow: view the talent's social links, and `--set` (interactive,
+// confirmation) to add/update/clear one. The write upserts the WHOLE object, so
+// we merge the chosen field into the current object and PUT it.
+
+const { styleLabelPrefix } = require('./ansi');
+const { NETWORKS } = require('./socials-client');
+
+function makeSocialsDeps(overrides = {}) {
+  const client = require('./socials-client');
+  return {
+    fetchSocials: (opts) => client.fetchSocials({}, opts),
+    saveSocials: (opts) => client.saveSocials({}, opts),
+    promptSelect: (opts) => require('./prompt-select').promptSelect(opts),
+    ...overrides,
+  };
+}
+
+function setNetworks(social) {
+  return NETWORKS.filter((k) => social && social[k]);
+}
+
+function renderView(io, fp, social) {
+  io.section(fp.title);
+  const present = setNetworks(social);
+  if (!present.length) { io.notify(fp.none); io.success(fp.done); return; }
+  present.forEach((k) => io.notify(styleLabelPrefix(fp.line(fp.networkLabel(k), social[k]))));
+  io.success(fp.done);
+}
+
+async function runSet({ io, ask, session, catalog, opts, deps }) {
+  const fp = catalog.socials;
+  const hubAccessToken = session ? session.hubAccessToken : null;
+  if (!opts.stdinIsTTY) { io.error(fp.setNeedsInteractive); return { ok: false, reason: 'non-interactive' }; }
+  const selOut = (s) => io.notify(s);
+
+  const cur = await io.withProgress(fp.loading, () => deps.fetchSocials({ hubAccessToken }));
+  if (!cur.ok) { io.error(fp.fetchFailed(cur.reason)); return { ok: false, reason: cur.reason }; }
+  const social = { ...cur.social };
+
+  io.section(fp.setTitle);
+  const present = setNetworks(social);
+  if (present.length) present.forEach((k) => io.notify(styleLabelPrefix(fp.line(fp.networkLabel(k), social[k]))));
+
+  const net = await deps.promptSelect({
+    ask, stdinIsTTY: opts.stdinIsTTY, out: selOut, header: fp.pickNetwork,
+    items: NETWORKS.map((k) => ({ label: fp.networkLabel(k), value: k })), labelFor: (x) => x.label, input: opts.input, output: opts.output,
+  });
+  if (!net) { io.notify(fp.setCancelled); return { ok: true, cancelled: true }; }
+  const key = net.value;
+
+  const raw = (await io.ask(fp.askUrl(fp.networkLabel(key)))).trim();
+  const value = raw === '' ? null : raw;
+  social[key] = value;
+
+  io.notify(value ? fp.setDiffSet(fp.networkLabel(key), value) : fp.setDiffClear(fp.networkLabel(key)));
+  const confirmed = await io.confirm(fp.setConfirm);
+  if (!confirmed) { io.notify(fp.setCancelled); return { ok: true, cancelled: true }; }
+
+  const res = await io.withProgress(fp.setSaving, () => deps.saveSocials({ hubAccessToken, social }));
+  if (!res.ok) { io.error(fp.setFailed(res.reason)); return { ok: false, reason: res.reason }; }
+  io.success(value ? fp.setDone(fp.networkLabel(key)) : fp.setCleared(fp.networkLabel(key)));
+  return { ok: true, set: { key, value } };
+}
+
+async function runSocials({ io, rawOut, ask, session, catalog, opts = {}, deps = makeSocialsDeps() }) {
+  const fp = catalog.socials;
+  if (opts.set) return runSet({ io, ask, session, catalog, opts, deps });
+
+  const hubAccessToken = session ? session.hubAccessToken : null;
+  const doFetch = () => deps.fetchSocials({ hubAccessToken });
+  const res = opts.json ? await doFetch() : await io.withProgress(fp.loading, doFetch);
+  if (!res.ok) { io.error(fp.fetchFailed(res.reason)); return { ok: false, reason: res.reason }; }
+  if (opts.json) {
+    (rawOut || ((s) => process.stdout.write(s)))(`${JSON.stringify({ ok: true, social: res.social }, null, 2)}\n`);
+    return { ok: true, social: res.social };
+  }
+  renderView(io, fp, res.social);
+  return { ok: true, social: res.social };
+}
+
+module.exports = { makeSocialsDeps, runSocials, setNetworks, renderView };

package/src/specificity-extract.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const { eachHumanText } = require('./transcript-turns');
+
+const MIN_INSTRUCTION_LEN = 12;
+
+const CONCRETE_RE =
+  /(`[^`]+`|\b[\w-]+\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|rb|php|css|scss|html|json|ya?ml|md|sql|sh|toml)\b|\/[\w./-]{2,}|"[^"]{2,}"|\d|\b(must|should|shouldn'?t|don'?t|do not|ensure|avoid|instead|because|so that|only|never|always|exactly|specifically|at least|at most|no more than|make sure|asegúrate|debe|deber[íi]as?|no (uses?|hagas|pongas)|en vez de|en lugar de|porque|exactamente|específicamente|solo|nunca|siempre)\b)/i;
+
+function makeSpecificityAccumulator() {
+  let instructionTurnCount = 0;
+  let specificInstructionCount = 0;
+  let totalInstructionLength = 0;
+  return {
+    add(text) {
+      const trimmed = typeof text === 'string' ? text.trim() : '';
+      if (trimmed.length < MIN_INSTRUCTION_LEN) return;
+      instructionTurnCount += 1;
+      totalInstructionLength += trimmed.length;
+      if (CONCRETE_RE.test(trimmed)) specificInstructionCount += 1;
+    },
+    result() {
+      if (instructionTurnCount === 0) return null;
+      return {
+        specificInstructionCount,
+        instructionTurnCount,
+        avgInstructionLength: Math.round(
+          totalInstructionLength / instructionTurnCount,
+        ),
+      };
+    },
+  };
+}
+
+function collectSpecificity(env = process.env, selectedCwds = null) {
+  const acc = makeSpecificityAccumulator();
+  for (const text of eachHumanText(env, { selectedCwds })) acc.add(text);
+  return acc.result();
+}
+
+module.exports = { collectSpecificity, makeSpecificityAccumulator };