@aifabrix/builder 2.51.0 → 2.51.1

package/lib/role-assistant/test-cases.js

@@ -0,0 +1,364 @@
+/**
+ * Role assistant test case loading and assertion helpers.
+ * @fileoverview Parse role-assistant/<roleKey>/tests/*.yaml and evaluate expectations
+ */
+
+'use strict';
+const path = require('path');
+const fs = require('../internal/fs-real-sync');
+const yaml = require('js-yaml');
+const { resolveExternalSystemPath } = require('../utils/app-path-resolve');
+const { VERDICT } = require('../lifecycle/product-model');
+const {
+  buildHonestyObservation,
+  evaluateHonestyExpectations
+} = require('./test-cases-honesty');
+function loadNodeFsSnapshot() {
+  if (global.__AIFABRIX_NODE_FS_UNMOCKED__) {
+    return global.__AIFABRIX_NODE_FS_UNMOCKED__;
+  }
+  return typeof jest !== 'undefined' && typeof jest.requireActual === 'function'
+    ? jest.requireActual('node:fs')
+    : require('node:fs');
+}
+const nodeFs = loadNodeFsSnapshot();
+const SUPPORTED_LIFECYCLE_STATES = new Set(['completed', 'question', 'approval-required', 'dependency', 'safe-stop', 'rejected', 'failed']);
+const LIFECYCLE_STATE_ALIASES = Object.freeze({
+  completed: ['completed', 'complete', 'done', 'success', 'verified'],
+  question: ['question', 'question_required', 'awaiting_question', 'pending_question'],
+  'approval-required': ['approval_required', 'awaiting_approval', 'pending_approval', 'requires_approval'],
+  dependency: ['dependency', 'dependency_wait', 'dependency_blocked', 'awaiting_dependency'],
+  'safe-stop': ['safe_stop', 'safe_stopped', 'policy_blocked', 'halted', 'paused'],
+  rejected: ['rejected', 'denied', 'declined', 'policy_rejected'],
+  failed: ['failed', 'error', 'errored', 'timeout', 'cancelled', 'canceled']
+});
+
+const WORK_STATUS_TO_LIFECYCLE = Object.freeze({
+  completed: 'completed', waiting: 'question', running: 'dependency', stopped: 'safe-stop'
+});
+const WAIT_REASON_TO_LIFECYCLE = Object.freeze({
+  ask: 'question', approval: 'approval-required', ownerroute: 'dependency',
+  realityconfirm: 'question', knowledgeconfirm: 'question'
+});
+const WORKER_TASK_STATUS_TO_LIFECYCLE = Object.freeze({
+  draft: 'dependency', pendingapproval: 'approval-required', approved: 'dependency',
+  running: 'dependency', completed: 'completed', failed: 'failed',
+  cancelled: 'rejected', canceled: 'rejected'
+});
+const WORKER_APPROVAL_STATE_TO_LIFECYCLE = Object.freeze({
+  pending: 'approval-required', approved: 'dependency', rejected: 'rejected'
+});
+function safeExistsSync(filePath) {
+  // Prefer unmocked node:fs so Jest worker fs mocks cannot hide real temp files.
+  return nodeFs.existsSync(filePath) || fs.existsSync(filePath);
+}
+function safeReadFileSync(filePath, encoding) {
+  if (nodeFs.existsSync(filePath)) {
+    return nodeFs.readFileSync(filePath, encoding);
+  }
+  return fs.readFileSync(filePath, encoding);
+}
+function safeReaddirSync(dirPath) {
+  if (nodeFs.existsSync(dirPath)) {
+    return nodeFs.readdirSync(dirPath);
+  }
+  return fs.readdirSync(dirPath);
+}
+function roleAssistantTestsDir(roleKey, options = {}) {
+  if (options.testsDir) {
+    return path.resolve(String(options.testsDir));
+  }
+  const root = resolveExternalSystemPath(roleKey, options.pathOptions || {});
+  return path.join(root, 'tests');
+}
+
+function parseCaseYamlFile(filePath) {
+  const raw = safeReadFileSync(filePath, 'utf8');
+  const parsed = yaml.load(raw);
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`Test case must be an object: ${filePath}`);
+  }
+  return parsed;
+}
+
+function normalizeCaseFromFile(filePath, parsed) {
+  const fileBase = path.basename(filePath, path.extname(filePath));
+  const caseId = String(parsed.caseId || fileBase).trim();
+  if (!caseId) {
+    throw new Error(`Test case is missing caseId: ${filePath}`);
+  }
+  const expected = parsed.expected && typeof parsed.expected === 'object' ? parsed.expected : {};
+  if (
+    expected.lifecycleState &&
+    !SUPPORTED_LIFECYCLE_STATES.has(String(expected.lifecycleState).trim())
+  ) {
+    throw new Error(
+      `Unsupported expected.lifecycleState "${expected.lifecycleState}" in ${filePath}`
+    );
+  }
+  return {
+    caseId,
+    input: parsed.input || {},
+    answers: Array.isArray(parsed.answers) ? parsed.answers : [],
+    approvals: Array.isArray(parsed.approvals) ? parsed.approvals : [],
+    expected,
+    sourceFile: filePath
+  };
+}
+
+function listTestCaseFiles(testsDir) {
+  if (!safeExistsSync(testsDir)) {
+    return [];
+  }
+  return safeReaddirSync(testsDir)
+    .filter((entry) => /\.(ya?ml)$/i.test(entry))
+    .map((entry) => path.join(testsDir, entry));
+}
+
+function looksLikePathSelector(selector) {
+  return (
+    selector.includes('/') ||
+    selector.includes('\\') ||
+    selector.startsWith('.') ||
+    /\.[a-z0-9]+$/i.test(selector)
+  );
+}
+
+function findCaseFileBySelector(files, selector) {
+  if (!selector) {
+    return files.length > 0 ? files[0] : null;
+  }
+  const normalized = String(selector).trim();
+  if (!normalized) {
+    return files.length > 0 ? files[0] : null;
+  }
+  const pathLikeSelector = looksLikePathSelector(normalized);
+  const byName = files.find((filePath) => {
+    const base = path.basename(filePath, path.extname(filePath));
+    return base === normalized;
+  });
+  if (byName) {
+    return byName;
+  }
+  for (const filePath of files) {
+    const parsed = parseCaseYamlFile(filePath);
+    const caseId = String(parsed.caseId || '').trim();
+    if (caseId === normalized) {
+      return filePath;
+    }
+  }
+  if (pathLikeSelector && safeExistsSync(normalized)) {
+    return path.resolve(normalized);
+  }
+  return null;
+}
+
+function fallbackCaseFileBySelector(testsDir, selector) {
+  const normalized = typeof selector === 'string' ? selector.trim() : '';
+  if (!normalized) return null;
+  const candidates = [path.join(testsDir, normalized), path.join(testsDir, `${normalized}.yaml`), path.join(testsDir, `${normalized}.yml`)];
+  return candidates.find((candidate) => safeExistsSync(candidate)) || null;
+}
+
+function loadRoleAssistantTestCase(roleKey, selector, options = {}) {
+  const testsDir = roleAssistantTestsDir(roleKey, options);
+  const files = listTestCaseFiles(testsDir);
+  const filePath = findCaseFileBySelector(files, selector) || fallbackCaseFileBySelector(testsDir, selector);
+  if (!filePath) {
+    const lookup = selector ? `"${selector}"` : '(default case)';
+    throw new Error(`Role assistant test case ${lookup} not found in ${testsDir}`);
+  }
+  const parsed = parseCaseYamlFile(filePath);
+  return normalizeCaseFromFile(filePath, parsed);
+}
+
+function normalizeLifecycleStateToken(value) {
+  if (typeof value !== 'string') {
+    return '';
+  }
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '');
+}
+
+function lifecycleStateFromToken(token) {
+  if (!token) {
+    return null;
+  }
+  for (const [state, aliases] of Object.entries(LIFECYCLE_STATE_ALIASES)) {
+    for (const alias of aliases) {
+      if (token === alias || token.startsWith(`${alias}_`)) {
+        return state;
+      }
+    }
+  }
+  return null;
+}
+
+function lifecycleStateFromSignalValue(value) {
+  if (value === null || value === undefined) {
+    return null;
+  }
+  if (typeof value === 'string') {
+    return lifecycleStateFromToken(normalizeLifecycleStateToken(value));
+  }
+  if (Array.isArray(value)) {
+    for (const row of value) {
+      const state = lifecycleStateFromSignalValue(row);
+      if (state) {
+        return state;
+      }
+    }
+    return null;
+  }
+  if (typeof value === 'object') {
+    const fields = [
+      'lifecycleState',
+      'state',
+      'status',
+      'code',
+      'type',
+      'reason',
+      'kind',
+      'category',
+      'errorCode'
+    ];
+    for (const field of fields) {
+      const state = lifecycleStateFromSignalValue(value[field]);
+      if (state) {
+        return state;
+      }
+    }
+  }
+  return null;
+}
+
+function mapWorkStatusFromResult(result) {
+  const rawStatus = normalizeLifecycleStateToken(result?.status);
+  if (rawStatus && WORK_STATUS_TO_LIFECYCLE[rawStatus]) {
+    const waitReason = normalizeLifecycleStateToken(result?.wait?.waitReason || '');
+    if (rawStatus === 'waiting' && waitReason && WAIT_REASON_TO_LIFECYCLE[waitReason]) {
+      return WAIT_REASON_TO_LIFECYCLE[waitReason];
+    }
+    return WORK_STATUS_TO_LIFECYCLE[rawStatus];
+  }
+  return null;
+}
+
+function mapWorkerTaskStateFromResult(result) {
+  const statusCandidates = [result?.task?.status, result?.status, result?.workerTask?.status];
+  for (const row of statusCandidates) {
+    const token = normalizeLifecycleStateToken(row);
+    if (token && WORKER_TASK_STATUS_TO_LIFECYCLE[token]) {
+      return WORKER_TASK_STATUS_TO_LIFECYCLE[token];
+    }
+  }
+  const approvalCandidates = [result?.task?.approvalState, result?.approvalState, result?.workerTask?.approvalState];
+  for (const row of approvalCandidates) {
+    const token = normalizeLifecycleStateToken(row);
+    if (token && WORKER_APPROVAL_STATE_TO_LIFECYCLE[token]) {
+      return WORKER_APPROVAL_STATE_TO_LIFECYCLE[token];
+    }
+  }
+  return null;
+}
+
+function resolveLifecycleStateFromResult(result) {
+  const workState = mapWorkStatusFromResult(result);
+  if (workState) {
+    return workState;
+  }
+  const workerTaskState = mapWorkerTaskStateFromResult(result);
+  if (workerTaskState) {
+    return workerTaskState;
+  }
+  const topLevelCandidates = [
+    result?.lifecycleState, result?.state, result?.status, result?.lifecycle?.state,
+    result?.report?.lifecycleState, result?.report?.state, result?.report?.status,
+    result?.report?.lifecycle?.state, result?.report?.runtime?.state, result?.report?.work?.state
+  ];
+  for (const candidate of topLevelCandidates) {
+    const state = lifecycleStateFromSignalValue(candidate);
+    if (state) {
+      return state;
+    }
+  }
+  const steps = Array.isArray(result?.stepsRun) ? result.stepsRun : [];
+  for (const row of steps) {
+    const stepCandidates = [
+      row?.lifecycleState, row?.state, row?.status, row?.code, row?.errorCode, row?.reason,
+      row?.kind, row?.type, row?.error, row?.failure, row?.details, row?.result
+    ];
+    for (const candidate of stepCandidates) {
+      const state = lifecycleStateFromSignalValue(candidate);
+      if (state) {
+        return state;
+      }
+    }
+  }
+  return null;
+}
+
+function deriveLifecycleState(result, lifecycleVerdict) {
+  if (lifecycleVerdict === VERDICT.VERIFIED) {
+    return 'completed';
+  }
+  const structuredState = resolveLifecycleStateFromResult(result);
+  if (structuredState) {
+    return structuredState;
+  }
+  if (lifecycleVerdict === VERDICT.NOT_VERIFIED) return 'safe-stop';
+  return 'failed';
+}
+
+function addCapabilityToken(set, value) {
+  if (typeof value === 'string' && value.trim()) set.add(value.trim());
+}
+
+function collectCapabilitiesFromWorkSteps(out, steps) {
+  if (!Array.isArray(steps)) return;
+  for (const row of steps) {
+    if (!row || typeof row !== 'object') continue;
+    addCapabilityToken(out, row.capabilityKey);
+    addCapabilityToken(out, row.capability);
+    addCapabilityToken(out, row.capabilityId);
+    if (row.executionOutcome && typeof row.executionOutcome === 'object') {
+      addCapabilityToken(out, row.executionOutcome.capabilityKey);
+      addCapabilityToken(out, row.executionOutcome.capability);
+    }
+  }
+}
+
+function collectObservedCapabilities(result) {
+  const out = new Set();
+  const steps = Array.isArray(result?.stepsRun) ? result.stepsRun : [];
+  for (const row of steps) {
+    if (row && typeof row.pillar === 'string' && row.pillar.trim()) {
+      out.add(row.pillar.trim());
+    }
+  }
+  collectCapabilitiesFromWorkSteps(out, result?.steps);
+  collectCapabilitiesFromWorkSteps(out, result?.workResult?.steps);
+  addCapabilityToken(out, result?.task?.capabilityKey);
+  addCapabilityToken(out, result?.task?.capability);
+  if (result?.task?.approvalContext && typeof result.task.approvalContext === 'object') {
+    addCapabilityToken(out, result.task.approvalContext.capabilityKey);
+    addCapabilityToken(out, result.task.approvalContext.capability);
+  }
+  return [...out];
+}
+
+module.exports = {
+  SUPPORTED_LIFECYCLE_STATES,
+  roleAssistantTestsDir,
+  loadRoleAssistantTestCase,
+  deriveLifecycleState,
+  collectObservedCapabilities,
+  buildHonestyObservation,
+  evaluateHonestyExpectations
+};
+
+const { evaluateRoleAssistantTestCase } = require('./test-cases-evaluate');
+module.exports.evaluateRoleAssistantTestCase = evaluateRoleAssistantTestCase;

package/lib/role-assistant/test-runner-workhub-answers.js

@@ -0,0 +1,203 @@
+/**
+ * Answer selection / synthesis for Work Hub human.respond waits.
+ * @fileoverview RA Work Hub wait answers
+ */
+
+'use strict';
+
+function resolveWorkHubAnswerValue(answer) {
+  if (answer === null || answer === undefined) {
+    return undefined;
+  }
+  if (typeof answer !== 'object') {
+    return answer;
+  }
+  if (answer.value !== undefined) {
+    return answer.value;
+  }
+  if (answer.answer !== undefined) {
+    return answer.answer;
+  }
+  if (answer.respond && typeof answer.respond === 'object' && answer.respond.value !== undefined) {
+    return answer.respond.value;
+  }
+  return undefined;
+}
+
+function pickAnswerForWait(answers, wait) {
+  const questionKey = String(wait.questionKey || wait.requestKey || '').trim().toLowerCase();
+  if (!questionKey) {
+    return null;
+  }
+  for (const entry of answers) {
+    if (!entry || typeof entry !== 'object') {
+      continue;
+    }
+    const when = entry.when && typeof entry.when === 'object' ? entry.when : {};
+    const matchKey = String(when.questionKey || when.requestKey || when.key || '')
+      .trim()
+      .toLowerCase();
+    if (matchKey && matchKey === questionKey) {
+      return entry;
+    }
+  }
+  return null;
+}
+
+function parseFieldsFromPrompt(prompt) {
+  const match = /\(fields:\s*([^)]+)\)/i.exec(String(prompt || ''));
+  if (!match) {
+    return [];
+  }
+  return match[1]
+    .split(',')
+    .map((row) => row.trim())
+    .filter(Boolean);
+}
+
+function extractObjectiveHints(objective) {
+  const text = String(objective || '');
+  const emailMatch = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i.exec(text);
+  const email = emailMatch ? emailMatch[0] : '';
+  const domain = email.includes('@') ? email.split('@')[1] : '';
+  const companyMatch =
+    /\b([A-Z][\w.&'-]*(?:\s+[\w.&'-]+){0,4}\s+Ltd\.?)\b/.exec(text) ||
+    /(?:for|customer)\s+([A-Z][\w.&'-]*(?:\s+[\w.&'-]+){0,3})/i.exec(text);
+  const name = companyMatch ? companyMatch[1].replace(/[.,]+$/, '').trim() : '';
+  const addressMatch = /(?:to|address)\s+(.+?)\s*$/i.exec(text);
+  const address = addressMatch ? addressMatch[1].trim() : '';
+  return { email, domain, name, address };
+}
+
+function fillFieldsFromHints(fields, hints) {
+  const out = {};
+  for (const key of fields) {
+    const lower = key.toLowerCase();
+    if (hints[lower]) {
+      out[key] = hints[lower];
+    } else if (lower.includes('mail') && hints.email) {
+      out[key] = hints.email;
+    } else if (lower.includes('name') && hints.name) {
+      out[key] = hints.name;
+    } else if (lower.includes('domain') && hints.domain) {
+      out[key] = hints.domain;
+    } else if (lower.includes('address') && hints.address) {
+      out[key] = hints.address;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function synthesizeFromCapability(capability, hints) {
+  const out = {};
+  if (capability.includes('contact')) {
+    if (hints.email) {
+      out.email = hints.email;
+    }
+    if (hints.name || hints.email) {
+      out.firstname = String(hints.email || 'user').split('@')[0];
+      out.lastname = hints.name || 'Contact';
+    }
+  } else if (capability.includes('deal')) {
+    if (hints.name) {
+      out.dealname = hints.name;
+    }
+  } else if (capability.includes('customer') || capability.includes('compan')) {
+    if (hints.name) {
+      out.name = hints.name;
+    }
+    if (hints.domain) {
+      out.domain = hints.domain;
+    }
+    if (hints.address) {
+      out.address = hints.address;
+    }
+  } else {
+    if (hints.name) {
+      out.name = hints.name;
+    }
+    if (hints.email) {
+      out.email = hints.email;
+    }
+    if (hints.domain) {
+      out.domain = hints.domain;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function synthesizeWaitAnswer(wait, statusRow, objective) {
+  const prompt = String(wait.prompt || statusRow?.message || '').trim();
+  const hints = extractObjectiveHints(objective);
+  const fields = parseFieldsFromPrompt(prompt);
+  if (fields.length > 0) {
+    return fillFieldsFromHints(fields, hints);
+  }
+  const kind = String(wait.objectRef?.kind || '').trim();
+  const isMissingInput =
+    kind === 'missingRequestBody' ||
+    kind === 'missingPathParams' ||
+    /missing required (request body|path params)/i.test(prompt);
+  if (!isMissingInput) {
+    return undefined;
+  }
+  const capability = String(wait.questionKey || wait.objectRef?.capabilityKey || '').toLowerCase();
+  return synthesizeFromCapability(capability, hints);
+}
+
+function resolveRespondValue(testCase, wait, statusRow, objective) {
+  const answers = Array.isArray(testCase.answers) ? testCase.answers : [];
+  const matched = pickAnswerForWait(answers, wait) || answers[0] || null;
+  const fromCase = matched ? resolveWorkHubAnswerValue(matched) : undefined;
+  if (fromCase !== undefined) {
+    return fromCase;
+  }
+  return synthesizeWaitAnswer(wait, statusRow, objective);
+}
+
+function waitRespondFingerprint(wait) {
+  return String(
+    wait.requestFingerprint || wait.requestKey || wait.questionKey || wait.prompt || 'wait'
+  ).trim();
+}
+
+function alreadyResponded(interactions, fingerprint) {
+  return interactions.some(
+    (row) => row && row.type === 'respond' && row.fingerprint === fingerprint
+  );
+}
+
+function buildRespondPayload(peId, wait, testCase, statusRow, interactions, objective) {
+  const answerType =
+    String(wait.answerType || wait.waitReason || 'ask').toLowerCase() === 'approval'
+      ? 'approval'
+      : 'ask';
+  const payload = {
+    respondIdempotencyKey: `ra-workhub-${peId}-${interactions.length}`,
+    answerType,
+    requestVersion: wait.requestVersion || undefined,
+    stateVersionRef: wait.stateVersionRef || undefined,
+    requestFingerprint: wait.requestFingerprint || undefined
+  };
+  if (answerType === 'approval') {
+    payload.approvalDecision = 'approved';
+    return payload;
+  }
+  const value = resolveRespondValue(testCase, wait, statusRow, objective);
+  if (value === undefined) {
+    return null;
+  }
+  payload.value = value;
+  return payload;
+}
+
+module.exports = {
+  resolveWorkHubAnswerValue,
+  pickAnswerForWait,
+  synthesizeWaitAnswer,
+  extractObjectiveHints,
+  resolveRespondValue,
+  waitRespondFingerprint,
+  alreadyResponded,
+  buildRespondPayload
+};