@aifabrix/builder 2.53.1 → 2.55.0

package/lib/role-assistant/test-pack-map.js

@@ -0,0 +1,180 @@
+/**
+ * Map local Role Assistant YAML cases to a published test pack (and back).
+ *
+ * @fileoverview YAML specification only — currentStatus stays on dataplane
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const yaml = require('js-yaml');
+const fs = require('../internal/fs-real-sync');
+const { roleAssistantTestsDir } = require('./test-cases');
+const { discoverSuiteCaseFiles } = require('./test-suite');
+const { roleAssistantSystemKey } = require('../utils/role-assistant-paths');
+
+const PACK_API_VERSION = 'dataplane.aifabrix.ai/v1';
+const PACK_KIND = 'RoleAssistantTestPack';
+const STATUS_KEYS = new Set(['currentStatus', 'lastTestedAt', 'summary', 'sourceFile']);
+const YAML_SPEC_KEYS = [
+  'caseId',
+  'input',
+  'answers',
+  'approvals',
+  'expected',
+  'preflight',
+  'metadata'
+];
+const PACK_INPUT_ALIASES = ['executionPath', 'roleRef', 'businessRoleRef'];
+
+function isYamlName(name) {
+  return /\.(ya?ml)$/i.test(name);
+}
+
+function listRootYamlFiles(testsDir) {
+  if (!fs.existsSync(testsDir)) {
+    return [];
+  }
+  return fs.readdirSync(testsDir)
+    .filter((name) => isYamlName(name))
+    .map((name) => path.join(testsDir, name));
+}
+
+function copySpecFields(parsed, caseId) {
+  const out = { caseId };
+  for (const key of YAML_SPEC_KEYS) {
+    if (key === 'caseId' || parsed[key] === undefined) {
+      continue;
+    }
+    out[key] = parsed[key];
+  }
+  const input = out.input && typeof out.input === 'object' && !Array.isArray(out.input)
+    ? out.input
+    : {};
+  for (const key of PACK_INPUT_ALIASES) {
+    if (input[key] !== undefined) {
+      out[key] = input[key];
+    }
+  }
+  return out;
+}
+
+function specCaseFromFile(filePath) {
+  const parsed = yaml.load(fs.readFileSync(filePath, 'utf8'));
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`Test case must be an object: ${filePath}`);
+  }
+  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}`);
+  }
+  return copySpecFields(parsed, caseId);
+}
+
+function collectSuiteMap(testsDir) {
+  const suites = new Map();
+  const add = (suiteId, filePath) => {
+    const id = String(suiteId || 'default').trim() || 'default';
+    if (!suites.has(id)) {
+      suites.set(id, []);
+    }
+    suites.get(id).push(specCaseFromFile(filePath));
+  };
+  for (const filePath of listRootYamlFiles(testsDir)) {
+    add('default', filePath);
+  }
+  for (const row of discoverSuiteCaseFiles(testsDir)) {
+    add(row.suite, row.absPath);
+  }
+  return suites;
+}
+
+function buildRoleAssistantTestPack(systemKey, suiteMap) {
+  const key = roleAssistantSystemKey(systemKey);
+  const suites = [];
+  for (const [suiteId, cases] of suiteMap.entries()) {
+    if (cases.length > 0) {
+      suites.push({ suiteId, cases });
+    }
+  }
+  return {
+    apiVersion: PACK_API_VERSION,
+    kind: PACK_KIND,
+    metadata: { key },
+    spec: { suites }
+  };
+}
+
+function mapLocalTestsToPack(systemKey, options = {}) {
+  const testsDir = roleAssistantTestsDir(systemKey, options);
+  if (!fs.existsSync(testsDir)) {
+    return { skipped: true, reason: 'No tests folder' };
+  }
+  const suiteMap = collectSuiteMap(testsDir);
+  const pack = buildRoleAssistantTestPack(systemKey, suiteMap);
+  if (!pack.spec.suites.length) {
+    return { skipped: true, reason: 'No test cases in tests folder' };
+  }
+  return { skipped: false, pack, testsDir };
+}
+
+function mergePackAliasesIntoInput(packCase, input) {
+  const next = { ...input };
+  for (const key of PACK_INPUT_ALIASES) {
+    if (packCase[key] !== undefined && next[key] === undefined) {
+      next[key] = packCase[key];
+    }
+  }
+  return next;
+}
+
+function yamlFromPackCase(packCase) {
+  const body = {};
+  for (const key of YAML_SPEC_KEYS) {
+    if (packCase[key] === undefined || STATUS_KEYS.has(key)) {
+      continue;
+    }
+    body[key] = packCase[key];
+  }
+  const input = body.input && typeof body.input === 'object' && !Array.isArray(body.input)
+    ? body.input
+    : {};
+  const merged = mergePackAliasesIntoInput(packCase, input);
+  if (Object.keys(merged).length > 0) {
+    body.input = merged;
+  }
+  return yaml.dump(body, { lineWidth: 120, noRefs: true, sortKeys: false });
+}
+
+function writePackToTestsDir(pack, testsDir) {
+  const suites = pack && pack.spec && Array.isArray(pack.spec.suites) ? pack.spec.suites : [];
+  fs.mkdirSync(testsDir, { recursive: true });
+  let written = 0;
+  for (const suite of suites) {
+    const suiteId = String((suite && suite.suiteId) || 'default').trim() || 'default';
+    const suiteDir = path.join(testsDir, suiteId);
+    fs.mkdirSync(suiteDir, { recursive: true });
+    const cases = Array.isArray(suite.cases) ? suite.cases : [];
+    for (const row of cases) {
+      const caseId = String((row && row.caseId) || '').trim();
+      if (!caseId) {
+        continue;
+      }
+      fs.writeFileSync(path.join(suiteDir, `${caseId}.yaml`), yamlFromPackCase(row), 'utf8');
+      written += 1;
+    }
+  }
+  return written;
+}
+
+module.exports = {
+  PACK_API_VERSION,
+  PACK_KIND,
+  YAML_SPEC_KEYS,
+  mapLocalTestsToPack,
+  writePackToTestsDir,
+  specCaseFromFile
+};

package/lib/role-assistant/test-pack-sync.js

@@ -0,0 +1,187 @@
+/**
+ * Role Assistant test-pack sidecar: upload PUT, download GET, case status PATCH.
+ *
+ * @fileoverview Shared CLI and builder-api adapters — no Task/PE or /runs
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const logger = require('../utils/logger');
+const { formatWarningLine } = require('../utils/cli-test-layout-chalk');
+const { isDigitalWorkerKind } = require('../utils/platform-shell-package');
+const { roleAssistantTestsDir } = require('./test-cases');
+const { mapLocalTestsToPack, writePackToTestsDir } = require('./test-pack-map');
+const {
+  upsertRoleAssistantTestPack,
+  getRoleAssistantTestPack,
+  patchRoleAssistantTestCaseStatus
+} = require('../api/role-assistant-test-pack.api');
+const fs = require('../internal/fs-real-sync');
+
+function skipResult(reason) {
+  return { skipped: true, reason };
+}
+
+function isRoleAssistantPayload(payload) {
+  return isDigitalWorkerKind(payload && payload.application);
+}
+
+async function runTestsSidecar(ctx, sidecar, quietSidecar) {
+  if (!isRoleAssistantPayload(ctx.payload)) {
+    sidecar.tests = skipResult('Not a Role Assistant package');
+    return;
+  }
+  if (ctx.options && ctx.options.dryRun === true) {
+    sidecar.tests = skipResult('Dry run');
+    return;
+  }
+  const mapped = mapLocalTestsToPack(ctx.systemKey, {
+    pathOptions: (ctx.options && ctx.options.pathOptions) || {},
+    testsDir: ctx.options && ctx.options.testsDir
+  });
+  if (mapped.skipped) {
+    sidecar.tests = skipResult(mapped.reason);
+    return;
+  }
+  try {
+    const uploaded = await upsertRoleAssistantTestPack(
+      ctx.dataplaneUrl,
+      ctx.authConfig,
+      ctx.systemKey,
+      mapped.pack
+    );
+    sidecar.tests = {
+      skipped: false,
+      packVersion: uploaded && uploaded.packVersion,
+      packKey: uploaded && uploaded.packKey
+    };
+  } catch (err) {
+    sidecar.tests = skipResult(err.message || String(err));
+    if (!quietSidecar) {
+      logger.log(formatWarningLine(`Role assistant tests upload skipped: ${err.message}`));
+    }
+  }
+}
+
+async function exportRoleAssistantTests(params) {
+  const { systemKey, dataplaneUrl, authConfig, options = {} } = params;
+  const row = await getRoleAssistantTestPack(dataplaneUrl, authConfig, systemKey, {
+    allowMissing: true
+  });
+  if (!row || !row.pack) {
+    return skipResult('No published test pack');
+  }
+  const testsDir = roleAssistantTestsDir(systemKey, {
+    pathOptions: options.pathOptions || {},
+    testsDir: options.testsDir
+  });
+  const written = writePackToTestsDir(row.pack, testsDir);
+  return { skipped: false, written, testsDir };
+}
+
+function publishedTestsOwnerToken() {
+  if (typeof process.getuid === 'function') {
+    return String(process.getuid());
+  }
+  return 'u';
+}
+
+function publishedTestsTempDir(systemKey) {
+  const key = String(systemKey || 'pack').replace(/[^a-zA-Z0-9._-]+/g, '_');
+  return path.join(os.tmpdir(), `aifabrix-ra-tests-${publishedTestsOwnerToken()}`, key);
+}
+
+async function materializePublishedTests(systemKey, dataplaneUrl, authConfig, destRoot) {
+  const row = await getRoleAssistantTestPack(dataplaneUrl, authConfig, systemKey, {
+    allowMissing: true
+  });
+  if (!row || !row.pack) {
+    throw new Error(
+      `No published tests for ${systemKey}. Upload the Role Assistant package first.`
+    );
+  }
+  if (fs.existsSync(destRoot)) {
+    fs.rmSync(destRoot, { recursive: true, force: true });
+  }
+  const written = writePackToTestsDir(row.pack, destRoot);
+  return { testsDir: destRoot, written };
+}
+
+function caseStatusFromEvaluation(evaluation) {
+  if (!evaluation) {
+    return 'skipped';
+  }
+  if (evaluation.passed === true) {
+    return 'passed';
+  }
+  if (evaluation.passed === false) {
+    return 'failed';
+  }
+  return 'skipped';
+}
+
+function caseSummaryFromEvaluation(evaluation) {
+  if (!evaluation) {
+    return undefined;
+  }
+  const summary = evaluation.summary || evaluation.reason || evaluation.error;
+  return typeof summary === 'string' && summary.trim() ? summary.trim() : undefined;
+}
+
+async function loadPublishedTestsIntoOptions(systemKey, opts, authContext) {
+  if (!opts || opts.fromDataplane !== true) {
+    return opts;
+  }
+  const dest = publishedTestsTempDir(systemKey);
+  await materializePublishedTests(
+    systemKey,
+    authContext.dataplaneUrl,
+    authContext.authConfig,
+    dest
+  );
+  return { ...opts, casesRoot: dest, testsDir: dest };
+}
+
+async function patchCaseStatusAfterRun(params) {
+  const { systemKey, caseId, evaluation, dataplaneUrl, authConfig } = params;
+  if (!dataplaneUrl || !authConfig || !caseId) {
+    return { skipped: true, reason: 'Missing dataplane context' };
+  }
+  const body = {
+    status: caseStatusFromEvaluation(evaluation),
+    testedAt: new Date().toISOString()
+  };
+  const summary = caseSummaryFromEvaluation(evaluation);
+  if (summary) {
+    body.summary = summary;
+  }
+  try {
+    await patchRoleAssistantTestCaseStatus(
+      dataplaneUrl,
+      authConfig,
+      systemKey,
+      caseId,
+      body
+    );
+    return { skipped: false, status: body.status };
+  } catch (err) {
+    logger.log(
+      formatWarningLine(`Could not update published case status for ${caseId}: ${err.message}`)
+    );
+    return { skipped: true, reason: err.message || String(err) };
+  }
+}
+
+module.exports = {
+  runTestsSidecar,
+  exportRoleAssistantTests,
+  publishedTestsTempDir,
+  materializePublishedTests,
+  loadPublishedTestsIntoOptions,
+  caseStatusFromEvaluation,
+  patchCaseStatusAfterRun
+};

package/lib/role-assistant/test-runner-debug.js

@@ -0,0 +1,54 @@
+/**
+ * Role assistant --debug Work Result fetch and log persistence.
+ *
+ * @fileoverview Technical work-result depth and logs under role-assistant/<role>/logs/
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('../internal/fs-real-sync');
+const path = require('path');
+const { getWorkExecutionResult } = require('../api/work.api');
+const { sanitizeForLog } = require('../utils/test-log-writer');
+const {
+  getRoleAssistantPath,
+  roleAssistantSystemKey
+} = require('../utils/role-assistant-paths');
+
+function requestedWorkResultDepth(options) {
+  return options && options.debug === true ? 'technical' : 'business';
+}
+
+async function fetchWorkHubResult(dataplaneUrl, authConfig, processExecutionId, options = {}) {
+  try {
+    const workResult = await getWorkExecutionResult(dataplaneUrl, authConfig, processExecutionId, {
+      requestedDepth: requestedWorkResultDepth(options),
+      format: 'json'
+    });
+    return { workResult, workResultError: null };
+  } catch (error) {
+    return { workResult: null, workResultError: error.message || String(error) };
+  }
+}
+
+function persistRoleAssistantDebugLog(roleKey, payload, options = {}) {
+  if (!options || options.debug !== true) {
+    return null;
+  }
+  const systemKey = roleAssistantSystemKey(roleKey);
+  const logsDir = path.join(getRoleAssistantPath(systemKey), 'logs');
+  fs.mkdirSync(logsDir, { recursive: true });
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const filePath = path.join(logsDir, `work-result-technical-${timestamp}.json`);
+  const sanitized = sanitizeForLog(payload);
+  fs.writeFileSync(filePath, `${JSON.stringify(sanitized, null, 2)}\n`, 'utf8');
+  return filePath;
+}
+
+module.exports = {
+  requestedWorkResultDepth,
+  fetchWorkHubResult,
+  persistRoleAssistantDebugLog
+};

package/lib/role-assistant/test-runner-respond-body.js

@@ -0,0 +1,36 @@
+/**
+ * Keep human.respond bodies on the OpenAPI request shape.
+ * WaitPayload.prompt is server-owned and must not be echoed.
+ * @fileoverview Strip extra wait fields from RA respond payloads
+ */
+
+'use strict';
+
+const HUMAN_RESPOND_KEYS = [
+  'respondIdempotencyKey',
+  'answerType',
+  'value',
+  'evidenceRef',
+  'declined',
+  'selectedOptionId',
+  'approvalDecision',
+  'proposedPatch',
+  'requestVersion',
+  'stateVersionRef',
+  'requestFingerprint'
+];
+
+function pickHumanRespondBody(payload) {
+  const out = {};
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return out;
+  }
+  for (const key of HUMAN_RESPOND_KEYS) {
+    if (payload[key] !== undefined) {
+      out[key] = payload[key];
+    }
+  }
+  return out;
+}
+
+module.exports = { pickHumanRespondBody };

package/lib/role-assistant/test-runner-search.js

@@ -0,0 +1,164 @@
+/**
+ * Role-assistant typed search cases (work.skills / work.search).
+ *
+ * @fileoverview Execute viewpoint and table search cases without Work Hub
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { getWorkSkills, searchWork } = require('../api/work-search.api');
+const { resourceTypesMap } = require('../search/search-skills');
+const { roleAssistantSystemKey } = require('../utils/role-assistant-paths');
+const {
+  resolveInput,
+  wantsSearchPath,
+  wantsSkillsOnlyPath
+} = require('./test-runner-workhub-helpers');
+
+function operationKeys(spec) {
+  const raw = Array.isArray(spec && spec.operations) ? spec.operations : [];
+  const keys = [];
+  for (const item of raw) {
+    if (typeof item === 'string' && item.trim()) {
+      keys.push(item.trim());
+      continue;
+    }
+    const key = item && typeof item === 'object' ? String(item.key || '').trim() : '';
+    if (key) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+
+function pickResourceType(skillsPayload, operation) {
+  const rts = resourceTypesMap(skillsPayload);
+  const keys = Object.keys(rts);
+  const wanted = String(operation || '').trim();
+  if (wanted) {
+    const hits = keys.filter((resourceType) => operationKeys(rts[resourceType]).includes(wanted));
+    if (hits.length === 1) {
+      return hits[0];
+    }
+  }
+  return keys.length === 1 ? keys[0] : '';
+}
+
+function resolveRoleRef(roleKey, testCase) {
+  const input = resolveInput(testCase);
+  const candidates = [
+    input.roleRef,
+    input.businessRoleRef,
+    testCase && testCase.roleRef,
+    testCase && testCase.businessRoleRef,
+    roleAssistantSystemKey(roleKey)
+  ];
+  for (const row of candidates) {
+    if (typeof row === 'string' && row.trim()) {
+      return row.trim();
+    }
+  }
+  return roleAssistantSystemKey(roleKey);
+}
+
+function assignOptionalNumber(args, input, key) {
+  if (Number.isFinite(input[key])) {
+    args[key] = input[key];
+  }
+}
+
+function assignGraphFields(args, input) {
+  if (input.graph === true) {
+    args.graph = { depth: 1 };
+  } else if (input.graph && typeof input.graph === 'object' && !Array.isArray(input.graph)) {
+    args.graph = { depth: 1 };
+  }
+  if (typeof input.query === 'string' && input.query.trim()) {
+    args.query = input.query.trim();
+  }
+  if (!Array.isArray(input.knowledgeKeys) || !input.knowledgeKeys.length) {
+    return;
+  }
+  const keys = input.knowledgeKeys.map((item) => String(item || '').trim()).filter(Boolean);
+  if (keys.length) {
+    args.knowledgeKeys = keys;
+  }
+}
+
+function buildSearchArguments(roleRef, input, skillsPayload) {
+  const args = { roleRef };
+  const resourceType =
+    String(input.resourceType || '').trim() || pickResourceType(skillsPayload, input.operation);
+  if (resourceType) {
+    args.resourceType = resourceType;
+  }
+  if (typeof input.operation === 'string' && input.operation.trim()) {
+    args.operation = input.operation.trim();
+  }
+  if (input.filters && typeof input.filters === 'object' && !Array.isArray(input.filters)) {
+    args.filters = input.filters;
+  }
+  assignOptionalNumber(args, input, 'page');
+  assignOptionalNumber(args, input, 'pageSize');
+  if (Array.isArray(input.fields) && input.fields.length) {
+    args.fields = input.fields;
+  }
+  assignGraphFields(args, input);
+  return args;
+}
+
+function statusToken(statusCode) {
+  return Number(statusCode) === 200 ? 'completed' : 'stopped';
+}
+
+function searchLifecycleResult(roleKey, testCase, roleRef, skillsRes, searchRes, args) {
+  return {
+    kind: searchRes ? 'search' : 'skills',
+    roleKey,
+    caseId: testCase.caseId,
+    roleRef,
+    processExecutionId: null,
+    skills: skillsRes,
+    search: searchRes ? { ...searchRes, arguments: args } : null,
+    finalStatus: {
+      status: statusToken((searchRes || skillsRes).status)
+    },
+    timeline: [],
+    interactions: [],
+    workResult: null,
+    workResultError: null
+  };
+}
+
+async function runSearchCaseLifecycle(roleKey, testCase, runtimeContext) {
+  const dataplaneUrl = runtimeContext && runtimeContext.dataplaneUrl;
+  const authConfig = runtimeContext && runtimeContext.authConfig;
+  if (!dataplaneUrl || !authConfig) {
+    throw new Error('Role assistant search case requires dataplane auth context.');
+  }
+  const roleRef = resolveRoleRef(roleKey, testCase);
+  const skillsRes = await getWorkSkills(dataplaneUrl, authConfig, roleRef);
+  if (wantsSkillsOnlyPath(testCase)) {
+    return searchLifecycleResult(roleKey, testCase, roleRef, skillsRes, null, null);
+  }
+  const args = buildSearchArguments(roleRef, resolveInput(testCase), skillsRes.payload);
+  if (!args.resourceType) {
+    throw new Error(
+      'Search case requires input.resourceType (or exactly one matching type from work.skills).'
+    );
+  }
+  const searchRes = await searchWork(dataplaneUrl, authConfig, args);
+  return searchLifecycleResult(roleKey, testCase, roleRef, skillsRes, searchRes, args);
+}
+
+module.exports = {
+  wantsSearchPath,
+  wantsSkillsOnlyPath,
+  operationKeys,
+  pickResourceType,
+  resolveRoleRef,
+  buildSearchArguments,
+  runSearchCaseLifecycle
+};