magic-builder 1.2.0 → 1.3.1

package/src/commands/performance.js

@@ -3,26 +3,82 @@
 const { existsSync, readFileSync } = require('fs');
 const { resolve } = require('path');
 const { success, fail } = require('../lib/output');
+const { getPerformanceConfigPath, loadPerformanceConfig } = require('../lib/config');
 
 const DEFAULTS = {
   endpoint: 'https://people.bytedance.net/perf/api/foundation/v2/draft',
+  submitEndpoint: 'https://people.bytedance.net/perf/api/review/v2/stage',
   settingsEndpoint: 'https://people.bytedance.net/perf/api/user/settings',
   draftEndpoint: 'https://people.bytedance.net/perf/api/foundation/draft',
 };
 
 async function run(args, opts) {
-  if (args.length) fail('Usage: magic-builder performance --cookie <content|file> --markdown <content|file|url>', 'E_INVALID_ARGS');
+  const action = args[0] || 'draft';
+  if (args.length > 1 || !['draft', 'submit', 'self-review', 'key-works', 'review-users', 'invite-review'].includes(action)) {
+    fail('Usage: magic-builder performance [submit|self-review|key-works|review-users|invite-review] --review-url <url> --cookie <content|file>', 'E_INVALID_ARGS');
+  }
 
   const cookie = readCookie(opts.cookie, opts.cookieFile);
   if (!cookie) fail('Missing Cookie. Use --cookie <content|file> or --cookie-file <file>.', 'E_INVALID_ARGS');
 
-  const markdown = await readMarkdown(opts.markdown, opts.markdownFile);
-  if (!markdown.trim()) fail('Missing Markdown. Use --markdown <content|file|url>, --markdown-file <file>, or stdin.', 'E_INVALID_ARGS');
-
   const csrf = getCookie(cookie, 'x-f-csrf');
   if (!csrf) fail('Cookie does not contain x-f-csrf.', 'E_INVALID_ARGS');
 
-  const config = await resolveConfig(opts, cookie);
+  if (action === 'key-works') {
+    const data = await getKeyWorks(opts, cookie, csrf);
+    success(data, opts);
+    return;
+  }
+  if (action === 'review-users') {
+    const data = await getReviewUsers(opts, cookie, csrf);
+    success(data, opts);
+    return;
+  }
+  if (action === 'invite-review') {
+    const payload = readInviteReviewPayload(opts);
+    const endpoint = String(opts.endpoint || DEFAULTS.endpoint);
+    if (opts.dryRun) {
+      success({ dryRun: true, action: 'invite-review', endpoint, payload }, opts);
+      return;
+    }
+    const review = parseReviewLocation(opts.reviewUrl || opts.referer);
+    const data = await postPerformance(endpoint, payload, cookie, csrf, {
+      referer: String(opts.referer || review.referer || 'https://people.bytedance.net/performance/perf/review'),
+      tenantId: String(opts.tenantId || ''),
+    });
+    success(data, opts);
+    return;
+  }
+
+  const config = await resolveConfig(opts, cookie, action === 'self-review' ? 'self_review' : 'confirm_invitation');
+  if (action === 'self-review') {
+    const updates = readSelfReviewInputs(opts);
+    const payload = buildSelfReviewPayloadFromDraft(config.draft, updates);
+    if (opts.dryRun) {
+      success({ dryRun: true, action: 'self-review', endpoint: config.endpoint, payload }, opts);
+      return;
+    }
+    const data = await postPerformance(config.endpoint, payload, cookie, csrf, config);
+    success(data, opts);
+    return;
+  }
+  if (action === 'submit') {
+    const payload = buildStagePayloadFromDraft(config.draft, config);
+    if (opts.dryRun) {
+      success({ dryRun: true, action: 'submit', endpoint: config.submitEndpoint, payload }, opts);
+      return;
+    }
+    if (!opts.yes) {
+      fail('Formal performance submission requires --yes. Run with --dry-run first to review the payload.', 'E_CONFIRM_REQUIRED');
+    }
+    const data = await postPerformance(config.submitEndpoint, payload, cookie, csrf, config);
+    success(data, opts);
+    return;
+  }
+
+  const markdown = await readMarkdown(opts.markdown, opts.markdownFile);
+  if (!markdown.trim()) fail('Missing Markdown. Use --markdown <content|file|url>, --markdown-file <file>, or stdin.', 'E_INVALID_ARGS');
+
   const payload = config.draft
     ? buildPayloadFromDraft(markdown, config.draft, config)
     : buildPayload(markdown, config);
@@ -31,7 +87,143 @@ async function run(args, opts) {
     return;
   }
 
-  const response = await fetch(config.endpoint, {
+  const data = await postPerformance(config.endpoint, payload, cookie, csrf, config);
+  success(data, opts);
+}
+
+function readInviteReviewPayload(opts) {
+  if (opts.payload && opts.payloadFile) {
+    fail('Pass either --payload or --payload-file, not both.', 'E_INVALID_ARGS');
+  }
+  const input = opts.payloadFile
+    ? readFileSync(resolve(String(opts.payloadFile)), 'utf8')
+    : String(opts.payload || '');
+  if (!input.trim()) fail('invite-review requires --payload <json> or --payload-file <file>.', 'E_INVALID_ARGS');
+  const payload = parseJson(input);
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    fail('Invite-review payload must be a valid JSON object.', 'E_INVALID_ARGS');
+  }
+  const missing = ['key', 'data', 'version'].filter(key => payload[key] === undefined || payload[key] === null);
+  if (missing.length) fail(`Invite-review payload is missing ${missing.join(', ')}.`, 'E_INVALID_ARGS');
+  if (!String(payload.key).includes('__invite_review__')) {
+    fail('Invite-review payload key must contain __invite_review__.', 'E_INVALID_ARGS');
+  }
+  return normalizePerformancePayload(payload);
+}
+
+function normalizePerformancePayload(payload) {
+  const normalized = structuredClone(payload);
+  normalizePerformanceNode(normalized);
+  return normalized;
+}
+
+function normalizePerformanceNode(node) {
+  if (!node || typeof node !== 'object') return;
+  if (Array.isArray(node)) {
+    node.forEach(normalizePerformanceNode);
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === 'insert' && typeof value === 'string') {
+      node[key] = value.replace(/\\n(?=\r?\n|$)/g, '\n');
+      continue;
+    }
+    if (typeof value === 'string' && ['text', 'value', 'rich_text'].includes(key)) {
+      const embedded = parseJson(value);
+      if (embedded && typeof embedded === 'object') {
+        normalizePerformanceNode(embedded);
+        node[key] = JSON.stringify(embedded);
+      }
+      continue;
+    }
+    normalizePerformanceNode(value);
+  }
+}
+
+async function getKeyWorks(opts, cookie, csrf) {
+  if (!opts.rootReviewId) {
+    fail('key-works requires --root-review-id <id>.', 'E_INVALID_ARGS');
+  }
+  const personalConfig = opts.performanceConfig || loadPerformanceConfig();
+  const templateId = String(opts.templateId || personalConfig.invite_review_template_id || personalConfig.inviteReviewTemplateId || '');
+  if (!templateId) {
+    fail(`Missing template id. Use --template-id <id> or set invite_review_template_id in ${getPerformanceConfigPath()}.`, 'E_INVALID_ARGS');
+  }
+  const endpoint = assertPeoplePerfEndpoint(opts.stageEndpoint || DEFAULTS.submitEndpoint);
+  endpoint.searchParams.set('template_id', templateId);
+  endpoint.searchParams.set('root_review_id', String(opts.rootReviewId));
+  const referer = String(opts.referer || opts.reviewUrl || 'https://people.bytedance.net/performance/perf/review');
+  const headers = {
+    accept: 'application/json, text/plain, */*',
+    'accept-language': 'zh-CN,zh;q=0.9',
+    cookie,
+    referer,
+    'x-f-csrf': csrf,
+    'x-f-lang': 'zh-CN',
+    'x-f-timezone': 'Asia/Shanghai',
+  };
+  if (opts.tenantId) headers['rpc-persist-lane-c-perfx-tenant-id'] = String(opts.tenantId);
+  const response = await fetch(endpoint, { method: 'GET', headers });
+  const text = await response.text();
+  const data = parseJson(text);
+  if (!response.ok) {
+    const error = new Error(data?.message || data?.msg || `Performance request failed: HTTP ${response.status}`);
+    error.code = response.status === 401 || response.status === 403 ? 'E_AUTH_FAILED' : 'E_REQUEST_FAILED';
+    throw error;
+  }
+  if (data === null) {
+    const error = new Error('Performance response is not valid JSON.');
+    error.code = 'E_REQUEST_FAILED';
+    throw error;
+  }
+  return data;
+}
+
+async function getReviewUsers(opts, cookie, csrf) {
+  const location = opts.reviewUrl ? parseReviewLocation(opts.reviewUrl) : {};
+  const reviewId = String(opts.reviewId || location.reviewId || '');
+  const stageId = String(opts.stageId || location.formId || '');
+  if (!reviewId || !stageId) {
+    fail('review-users requires --review-url <url> or both --review-id <id> and --stage-id <id>.', 'E_INVALID_ARGS');
+  }
+  const base = assertPeoplePerfEndpoint(opts.reviewUsersEndpoint || DEFAULTS.submitEndpoint);
+  const endpoint = new URL(`${base.origin}/perf/api/review/v2/stage/${encodeURIComponent(reviewId)}/list_invite_review`);
+  const referer = String(opts.referer || location.referer || `https://people.bytedance.net/performance/perf/review/${reviewId}/${stageId}/members`);
+  const headers = {
+    accept: 'application/json, text/plain, */*',
+    'accept-language': 'zh-CN,zh;q=0.9',
+    'content-type': 'application/json;charset=UTF-8',
+    cookie,
+    origin: 'https://people.bytedance.net',
+    referer,
+    'x-f-csrf': csrf,
+    'x-f-lang': 'zh-CN',
+    'x-f-timezone': 'Asia/Shanghai',
+  };
+  if (opts.tenantId) headers['rpc-persist-lane-c-perfx-tenant-id'] = String(opts.tenantId);
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ stage_id: stageId }),
+  });
+  const text = await response.text();
+  const data = parseJson(text);
+  if (!response.ok) {
+    const error = new Error(data?.message || data?.msg || `Performance request failed: HTTP ${response.status}`);
+    error.code = response.status === 401 || response.status === 403 ? 'E_AUTH_FAILED' : 'E_REQUEST_FAILED';
+    throw error;
+  }
+  if (data === null) {
+    const error = new Error('Performance response is not valid JSON.');
+    error.code = 'E_REQUEST_FAILED';
+    throw error;
+  }
+  return data;
+}
+
+async function postPerformance(endpoint, payload, cookie, csrf, config) {
+  assertPeoplePerfEndpoint(endpoint);
+  const response = await fetch(endpoint, {
     method: 'POST',
     headers: {
       accept: 'application/json, text/plain, */*',
@@ -55,7 +247,7 @@ async function run(args, opts) {
     error.code = response.status === 401 || response.status === 403 ? 'E_AUTH_FAILED' : 'E_REQUEST_FAILED';
     throw error;
   }
-  success(data === null ? text : data, opts);
+  return data === null ? text : data;
 }
 
 function readCookie(value, file) {
@@ -105,20 +297,21 @@ function getCookie(cookie, name) {
   return '';
 }
 
-async function resolveConfig(opts, cookie) {
+async function resolveConfig(opts, cookie, draftKind = 'confirm_invitation') {
   const review = parseReviewLocation(opts.reviewUrl || opts.referer, opts.reviewId, opts.formId);
   if (review.reviewId && review.formId) {
     const settings = await requestJson(opts.settingsEndpoint || DEFAULTS.settingsEndpoint, cookie, review.referer);
     const operatorId = String(opts.operatorId || settings?.data?.user?.id || '');
     const tenantId = String(opts.tenantId || settings?.data?.tenant?.id || '');
     if (!operatorId) fail('Unable to resolve operator id from /perf/api/user/settings.', 'E_REQUEST_FAILED');
-    const key = `${review.reviewId}__confirm_invitation__${operatorId}__${review.formId}`;
+    const key = buildDraftKey(review.reviewId, draftKind, operatorId, review.formId);
     const draftUrl = new URL(opts.draftEndpoint || DEFAULTS.draftEndpoint);
     draftUrl.searchParams.set('key', key);
     const draftResponse = await requestJson(draftUrl.toString(), cookie, review.referer);
     if (!draftResponse?.success || !draftResponse?.data) fail('Unable to load the current performance draft.', 'E_REQUEST_FAILED');
     return {
       endpoint: String(opts.endpoint || DEFAULTS.endpoint),
+      submitEndpoint: String(opts.submitEndpoint || DEFAULTS.submitEndpoint),
       reviewId: review.reviewId,
       formId: review.formId,
       operatorId,
@@ -126,6 +319,7 @@ async function resolveConfig(opts, cookie) {
       referer: review.referer,
       uid: String(opts.uid || `magic-builder-${Date.now()}`),
       version: opts.draftVersion === undefined ? undefined : Number(opts.draftVersion),
+      templateGroupId: String(opts.templateGroupId || ''),
       draft: draftResponse.data,
     };
   }
@@ -137,6 +331,7 @@ async function resolveConfig(opts, cookie) {
   }
   return {
     endpoint: String(opts.endpoint || DEFAULTS.endpoint),
+    submitEndpoint: String(opts.submitEndpoint || DEFAULTS.submitEndpoint),
     reviewId: String(opts.reviewId),
     formId: String(opts.formId),
     templateId: String(opts.templateId),
@@ -147,6 +342,7 @@ async function resolveConfig(opts, cookie) {
     sourceId: String(opts.sourceId),
     fieldSourceId: String(opts.fieldSourceId),
     rootReviewId: String(opts.rootReviewId),
+    templateGroupId: String(opts.templateGroupId || ''),
     version: Number(opts.draftVersion || opts.version),
     tenantId: String(opts.tenantId || ''),
     referer: String(opts.referer || `https://people.bytedance.net/performance/perf/review/${opts.reviewId}/${opts.formId}?mode=editable`),
@@ -154,6 +350,36 @@ async function resolveConfig(opts, cookie) {
   };
 }
 
+function buildDraftKey(reviewId, draftKind, operatorId, formId) {
+  return `${reviewId}__${draftKind}__${operatorId}__${formId}`;
+}
+
+function readSelfReviewInputs(opts) {
+  const inputs = [
+    ['good', 'goodFile'],
+    ['improve', 'improveFile'],
+    ['valuesComment', 'valuesCommentFile'],
+  ];
+  const updates = {};
+  for (const [valueKey, fileKey] of inputs) {
+    const hasValue = Object.prototype.hasOwnProperty.call(opts, valueKey);
+    const hasFile = Object.prototype.hasOwnProperty.call(opts, fileKey);
+    if (hasValue && hasFile) {
+      fail(`Pass either --${toKebab(valueKey)} or --${toKebab(fileKey)}, not both.`, 'E_INVALID_ARGS');
+    }
+    if (hasFile) updates[valueKey] = readFileSync(resolve(String(opts[fileKey])), 'utf8');
+    else if (hasValue) updates[valueKey] = String(opts[valueKey]);
+  }
+  if (!Object.keys(updates).length) {
+    fail('Pass at least one of --good, --improve, or --values-comment (or the matching --*-file option).', 'E_INVALID_ARGS');
+  }
+  return updates;
+}
+
+function toKebab(value) {
+  return String(value).replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
+}
+
 function parseReviewLocation(value, reviewId, formId) {
   if (reviewId && formId) {
     return {
@@ -172,6 +398,7 @@ function parseReviewLocation(value, reviewId, formId) {
 }
 
 async function requestJson(url, cookie, referer) {
+  assertPeoplePerfEndpoint(url);
   const response = await fetch(url, {
     headers: { accept: 'application/json, text/plain, */*', cookie, referer },
   });
@@ -181,6 +408,16 @@ async function requestJson(url, cookie, referer) {
   return data;
 }
 
+function assertPeoplePerfEndpoint(value) {
+  const url = new URL(String(value || ''));
+  if (url.origin !== 'https://people.bytedance.net' || !url.pathname.startsWith('/perf/api/')) {
+    const error = new Error('Performance API endpoint must use https://people.bytedance.net/perf/api/.');
+    error.code = 'E_INVALID_ARGS';
+    throw error;
+  }
+  return url;
+}
+
 function buildPayload(markdown, config) {
   const now = Date.now();
   const sections = splitMarkdownSections(markdown);
@@ -256,6 +493,92 @@ function buildPayloadFromDraft(markdown, draft, config) {
   };
 }
 
+function buildSelfReviewPayloadFromDraft(draft, updates) {
+  const snapshot = structuredClone(draft);
+  const units = snapshot?.data?.units;
+  if (!Array.isArray(units)) throw selfReviewSchemaError('Current self-review draft does not contain data.units.');
+  const fields = units.flatMap(unit => Array.isArray(unit?.fields) ? unit.fields : []);
+  const textFields = fields.filter(field => field?.entityType === 'text');
+  const tagTextFields = fields.filter(field => field?.entityType === 'tag_text');
+  if (textFields.length !== 2 || tagTextFields.length !== 1) {
+    throw selfReviewSchemaError('Unable to identify the self-review text fields from the current template.');
+  }
+  if (Object.prototype.hasOwnProperty.call(updates, 'good')) {
+    textFields[0].value = selfReviewTextValue(updates.good);
+  }
+  if (Object.prototype.hasOwnProperty.call(updates, 'improve')) {
+    textFields[1].value = selfReviewTextValue(updates.improve);
+  }
+  if (Object.prototype.hasOwnProperty.call(updates, 'valuesComment')) {
+    tagTextFields[0].json_value = selfReviewTextValue(updates.valuesComment);
+  }
+  return {
+    key: snapshot.key,
+    data: snapshot.data,
+    version: Number(snapshot.version),
+  };
+}
+
+function selfReviewSchemaError(message) {
+  const error = new Error(message);
+  error.code = 'E_REQUEST_FAILED';
+  return error;
+}
+
+function selfReviewTextValue(text) {
+  return { '0': { ops: markdownToDelta(String(text)), zoneId: '0', zoneType: 'Z' } };
+}
+
+function buildStagePayloadFromDraft(draft, config = {}) {
+  if (!draft?.data?.keyWorks) fail('Current draft does not contain keyWorks.', 'E_REQUEST_FAILED');
+  const keyWorks = structuredClone(draft.data.keyWorks);
+  const stageId = String(config.stageId || config.formId || '');
+  const rootReviewId = String(config.rootReviewId || draft.data.rootReviewId || draft.data.root_review_id || '');
+  const templateId = String(config.templateId || keyWorks.template_id || keyWorks.templateId || '');
+  const templateGroupId = String(
+    config.templateGroupId
+      || draft.data.templateGroupId
+      || draft.data.template_group_id
+      || keyWorks.templateGroupId
+      || keyWorks.template_group_id
+      || ''
+  );
+  const missing = [
+    ['root_review_id', rootReviewId],
+    ['template_id', templateId],
+    ['template_group_id', templateGroupId],
+    ['stage_id', stageId],
+  ].filter(([, value]) => !value).map(([name]) => name);
+  if (missing.length) {
+    fail(`Unable to build formal submission payload; missing ${missing.join(', ')}. Pass --template-group-id when it is absent from the draft.`, 'E_INVALID_ARGS');
+  }
+  if (!Array.isArray(keyWorks.units) || !keyWorks.units.length) {
+    fail('Current draft does not contain keyWorks.units.', 'E_REQUEST_FAILED');
+  }
+  return {
+    root_review_id: rootReviewId,
+    template_id: templateId,
+    template_group_id: templateGroupId,
+    stage_id: stageId,
+    stage_ids: [stageId],
+    data: { units: keyWorks.units.filter(unit => unit?.type === 'object').map(serializeStageUnit) },
+  };
+}
+
+function serializeStageUnit(unit) {
+  const output = structuredClone(unit);
+  for (const field of output.fields || []) {
+    delete field.json_value;
+    for (const group of field.sub_units || []) {
+      for (const subUnit of group || []) {
+        if (subUnit?.value && typeof subUnit.value !== 'string') subUnit.value = JSON.stringify(subUnit.value);
+        delete subUnit.json_value;
+      }
+    }
+  }
+  return output;
+}
+
 function createSubUnits(markdown, textFieldId, sourceId, now = Date.now()) {
   return splitMarkdownSections(markdown).map((section, index) => {
     const value = { '0': { ops: markdownToDelta(section), zoneId: '0', zoneType: 'Z' } };
@@ -273,17 +596,28 @@ function splitMarkdownSections(markdown) {
   for (const line of lines) {
     if (/^##\s+/.test(line)) {
       if (current.some(item => item.trim()) && !current.every(item => /^#\s+/.test(item) || !item.trim())) {
-        sections.push(current.join('\n').trim());
+        sections.push(cleanMarkdownSection(current.join('\n')));
       }
       current = [`# ${line.replace(/^##\s+/, '')}`];
     } else if (current.length || !/^#\s+/.test(line)) {
       current.push(line);
     }
   }
-  if (current.some(item => item.trim())) sections.push(current.join('\n').trim());
+  if (current.some(item => item.trim())) sections.push(cleanMarkdownSection(current.join('\n')));
   return sections.length ? sections : [text];
 }
 
+function cleanMarkdownSection(value) {
+  const cleaned = String(value || '').trim().replace(/(?:\n\s*(?:---+|\*\*\*+|___+)\s*)+$/u, '').trim();
+  return cleaned.split('\n').map((line, index) => {
+    if (index === 0) return line.replace(/^#{1,6}\s+/, '# ');
+    if (!line.trim() || /^\s*(?:[-*+]\s+|\d+[.)]\s+)/u.test(line)) return line;
+    if (/^\s*[-*+]\S/u.test(line)) return line.replace(/^(\s*[-*+])\s*/u, '$1 ');
+    if (/^\s*\d+[.)]\S/u.test(line)) return line.replace(/^(\s*\d+[.)])\s*/u, '$1 ');
+    return `- ${line.trim()}`;
+  }).join('\n');
+}
+
 function markdownToDelta(markdown) {
   const lines = String(markdown || '').replace(/\r\n?/g, '\n').split('\n');
   const ops = [];
@@ -298,18 +632,29 @@ function markdownToDelta(markdown) {
       ops.push({ insert: '\n', attributes: { 'code-block': true } });
       continue;
     }
+    if (!line.trim()) continue;
     const heading = line.match(/^(#{1,6})\s+(.+)$/);
-    const unordered = line.match(/^\s*[-*+]\s+(.+)$/);
-    const ordered = line.match(/^\s*\d+[.)]\s+(.+)$/);
+    const unordered = line.match(/^(\s*)[-*+]\s+(.+)$/);
+    const ordered = line.match(/^(\s*)(\d+)[.)]\s+(.+)$/);
     const quote = line.match(/^\s*>\s?(.*)$/);
-    const content = heading?.[2] ?? unordered?.[1] ?? ordered?.[1] ?? quote?.[1] ?? line;
-    appendInline(ops, content);
-    const attributes = heading ? { header: heading[1].length }
-      : unordered ? { list: 'bullet' }
-        : ordered ? { list: 'ordered' }
-          : quote ? { blockquote: true }
-            : undefined;
-    ops.push(attributes ? { insert: '\n', attributes } : { insert: '\n' });
+    if (heading) {
+      ops.push({ insert: `${heading[1]} ${heading[2]}`, attributes: { bold: true } });
+      ops.push({ insert: '\n' });
+      continue;
+    }
+    if (unordered || ordered) {
+      const indent = (unordered?.[1] || ordered?.[1] || '').replace(/\t/g, '  ').length;
+      const level = Math.max(1, Math.floor(indent / 2) + 1);
+      const list = `${unordered ? 'bullet' : 'ordered'}${level}`;
+      const marker = unordered ? '*' : `${ordered[2]}.`;
+      const content = unordered?.[2] ?? ordered?.[3] ?? '';
+      ops.push({ insert: marker, attributes: { list, lmkr: '1' } });
+      appendInline(ops, content);
+      ops.push({ insert: '\n' });
+      continue;
+    }
+    appendInline(ops, quote?.[1] ?? line);
+    ops.push(quote ? { insert: '\n', attributes: { blockquote: true } } : { insert: '\n' });
   }
   if (ops.length > 1 && lines.at(-1) === '') ops.pop();
   return ops.length ? ops : [{ insert: '\n' }];
@@ -334,4 +679,4 @@ function parseJson(text) {
   try { return text ? JSON.parse(text) : {}; } catch (_) { return null; }
 }
 
-module.exports = { run, readCookie, normalizeCookie, getCookie, parseReviewLocation, splitMarkdownSections, markdownToDelta, buildPayload, buildPayloadFromDraft };
+module.exports = { run, getKeyWorks, getReviewUsers, readInviteReviewPayload, normalizePerformancePayload, readCookie, normalizeCookie, getCookie, readSelfReviewInputs, buildDraftKey, parseReviewLocation, splitMarkdownSections, markdownToDelta, buildPayload, buildPayloadFromDraft, buildSelfReviewPayloadFromDraft, buildStagePayloadFromDraft, assertPeoplePerfEndpoint };

package/src/commands/skill.js

@@ -24,7 +24,7 @@ async function run(args, opts) {
   if (sub !== 'check-update' && sub !== 'update' && sub !== 'install') {
     fail('Usage: magic-builder skill <check-update|update|install>', 'E_INVALID_ARGS');
   }
-  const skillsRoot = path.resolve(opts.skillsRoot || path.join(os.homedir(), '.codex', 'skills'));
+  const skillsRoot = path.resolve(opts.skillsRoot || defaultSkillsRoot());
   const environment = resolveEnvironment(String(opts.environment || 'auto'), skillsRoot);
   const remote = await prepareRemotePackage();
   const report = buildReport(remote, skillsRoot, environment);
@@ -106,7 +106,7 @@ function buildCloudUpdateDescriptor(report, options = {}) {
     }] : [],
     instructions: [
       'Use the cloud runtime managed skill update/install mechanism.',
-      'Do not copy files into ~/.codex/skills or overwrite local filesystem paths in cloud mode.',
+      'Do not copy files into ~/.agents/skills or overwrite local filesystem paths in cloud mode.',
       'If no managed cloud updater is exposed, report this descriptor and do not claim the update was applied.',
     ],
   };
@@ -142,7 +142,7 @@ function readSkillMetadata(skillDir) {
   if (!fs.existsSync(skillPath)) return { exists: false, name: null, version: null, path: skillPath };
   const text = fs.readFileSync(skillPath, 'utf8');
   const nameMatch = text.match(/^name:\s*["']?([^"'\n]+)["']?\s*$/m);
-  const versionMatch = text.match(/^version:\s*["']?([^"'\n]+)["']?\s*$/m);
+  const versionMatch = text.match(/^\s*version:\s*["']?([^"'\n]+)["']?\s*$/m);
   return {
     exists: true,
     name: nameMatch ? nameMatch[1].trim() : null,
@@ -189,4 +189,8 @@ function ensureSafeSkillId(id) {
   if (!/^[a-z0-9][a-z0-9-]*$/i.test(id)) throw new Error(`Unsafe skill id in update package: ${id}`);
 }
 
-module.exports = { run };
+function defaultSkillsRoot(homeDir = os.homedir()) {
+  return path.join(homeDir, '.agents', 'skills');
+}
+
+module.exports = { run, defaultSkillsRoot };