@aifabrix/builder 2.52.0 → 2.53.0

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

@@ -68,7 +68,18 @@ function buildHonestyObservation(workResult) {
   };
 }
 
-function pushHonestyAssertion(assertions, id, passed, message) {
+function pushHonestyAssertion(assertions, id, passed, message, options = {}) {
+  const soft = options.soft === true;
+  if (soft && !passed) {
+    assertions.push({
+      id,
+      passed: true,
+      soft: true,
+      warn: true,
+      message: `${message} (soft — warning only)`
+    });
+    return;
+  }
   assertions.push({ id, passed, message });
 }
 
@@ -87,7 +98,7 @@ function assertWorkResultPresent(assertions, honesty, observation) {
   );
 }
 
-function assertSchemaVersion(assertions, honestySpec, honesty) {
+function assertSchemaVersion(assertions, honestySpec, honesty, soft) {
   if (!honestySpec.schemaVersion) {
     return;
   }
@@ -99,11 +110,12 @@ function assertSchemaVersion(assertions, honestySpec, honesty) {
     passed,
     passed
       ? `schemaVersion matched "${expected}".`
-      : `schemaVersion expected "${expected}" but got ${JSON.stringify(honesty.schemaVersion)}.`
+      : `schemaVersion expected "${expected}" but got ${JSON.stringify(honesty.schemaVersion)}.`,
+    { soft }
   );
 }
 
-function assertCompletion(assertions, honestySpec, honesty) {
+function assertCompletion(assertions, honestySpec, honesty, soft) {
   if (honestySpec.requireCompletion === false) {
     return;
   }
@@ -115,11 +127,12 @@ function assertCompletion(assertions, honestySpec, honesty) {
     stateOk && goalOk,
     stateOk && goalOk
       ? `completion.state/goalStatus honest (${honesty.completionState}/${honesty.goalStatus}).`
-      : `completion missing or invalid: state=${JSON.stringify(honesty.completionState)} goalStatus=${JSON.stringify(honesty.goalStatus)}.`
+      : `completion missing or invalid: state=${JSON.stringify(honesty.completionState)} goalStatus=${JSON.stringify(honesty.goalStatus)}.`,
+    { soft }
   );
 }
 
-function assertContribution(assertions, honestySpec, honesty) {
+function assertContribution(assertions, honestySpec, honesty, soft) {
   if (honestySpec.requireContributionObservation === false) {
     return;
   }
@@ -130,7 +143,8 @@ function assertContribution(assertions, honestySpec, honesty) {
     ok,
     ok
       ? `contributionObservation.status honest (${honesty.contributionStatus}).`
-      : `contributionObservation.status missing or invalid: ${JSON.stringify(honesty.contributionStatus)}.`
+      : `contributionObservation.status missing or invalid: ${JSON.stringify(honesty.contributionStatus)}.`,
+    { soft }
   );
 }
 
@@ -171,9 +185,9 @@ function evaluateHonestyExpectations(honestySpec, observation, options = {}) {
     // Missing Output is always a hard failure when required — soft does not waive it.
     return assertions;
   }
-  assertSchemaVersion(assertions, honestySpec, honesty);
-  assertCompletion(assertions, honestySpec, honesty);
-  assertContribution(assertions, honestySpec, honesty);
+  assertSchemaVersion(assertions, honestySpec, honesty, soft);
+  assertCompletion(assertions, honestySpec, honesty, soft);
+  assertContribution(assertions, honestySpec, honesty, soft);
   assertMinResourceChanges(assertions, honestySpec, honesty, soft);
   return assertions;
 }

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

@@ -331,6 +331,32 @@ function collectCapabilitiesFromWorkSteps(out, steps) {
   }
 }
 
+/**
+ * Work-result artifactIndex often carries CIP fingerprints like
+ * `capabilityKey=customer.createBasic|operationId=createbasic` when steps[] is empty.
+ * @param {Set<string>} out
+ * @param {unknown} artifacts
+ */
+function collectCapabilitiesFromArtifactIndex(out, artifacts) {
+  if (!Array.isArray(artifacts)) return;
+  for (const row of artifacts) {
+    if (!row || typeof row !== 'object') continue;
+    addCapabilityToken(out, row.capabilityKey);
+    addCapabilityToken(out, row.capability);
+    const fingerprint = typeof row.fingerprint === 'string' ? row.fingerprint : '';
+    const match = fingerprint.match(/(?:^|[|,])capabilityKey=([^|,]+)/);
+    if (match) {
+      addCapabilityToken(out, match[1]);
+    }
+    const artifactRef = typeof row.artifactRef === 'string' ? row.artifactRef : '';
+    // cip-log:fallback:customer.create:create:<id>
+    const refMatch = artifactRef.match(/^cip-log:[^:]+:([^:]+):/);
+    if (refMatch) {
+      addCapabilityToken(out, refMatch[1]);
+    }
+  }
+}
+
 function collectObservedCapabilities(result) {
   const out = new Set();
   const steps = Array.isArray(result?.stepsRun) ? result.stepsRun : [];
@@ -341,6 +367,8 @@ function collectObservedCapabilities(result) {
   }
   collectCapabilitiesFromWorkSteps(out, result?.steps);
   collectCapabilitiesFromWorkSteps(out, result?.workResult?.steps);
+  collectCapabilitiesFromArtifactIndex(out, result?.workResult?.artifactIndex);
+  collectCapabilitiesFromArtifactIndex(out, result?.artifactIndex);
   addCapabilityToken(out, result?.task?.capabilityKey);
   addCapabilityToken(out, result?.task?.capability);
   if (result?.task?.approvalContext && typeof result.task.approvalContext === 'object') {

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

@@ -0,0 +1,118 @@
+/**
+ * Build work.start attachments from case YAML (paths / openapiDir).
+ * @fileoverview 517.1 — map suite OpenAPI files to ATT attachment shape
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('../internal/fs-real-sync');
+
+function resolveCaseDirectory(testCase) {
+  const sourceFile =
+    testCase && typeof testCase.sourceFile === 'string' ? testCase.sourceFile.trim() : '';
+  if (!sourceFile) {
+    return process.cwd();
+  }
+  return path.dirname(path.resolve(sourceFile));
+}
+
+function readJsonAttachmentBody(absolutePath) {
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Role assistant attachment file not found: ${absolutePath}`);
+  }
+  const text = fs.readFileSync(absolutePath, 'utf8');
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`Role assistant attachment is not valid JSON: ${absolutePath}`);
+  }
+}
+
+function attachmentFromFile(absolutePath, meta = {}) {
+  const basename = path.basename(absolutePath);
+  const role = typeof meta.role === 'string' && meta.role.trim() ? meta.role.trim() : 'openapi';
+  return {
+    name: basename,
+    filename: basename,
+    mediaType: 'application/json',
+    role,
+    contributionPurpose: 'task',
+    body: readJsonAttachmentBody(absolutePath)
+  };
+}
+
+function resolveRelativeAttachmentPath(caseDir, relativePath) {
+  if (typeof relativePath !== 'string' || !relativePath.trim()) {
+    throw new Error('Role assistant attachment path must be a non-empty string');
+  }
+  const absolutePath = path.resolve(caseDir, relativePath.trim());
+  return absolutePath;
+}
+
+function collectExplicitAttachments(caseDir, attachments) {
+  if (!Array.isArray(attachments) || attachments.length === 0) {
+    return [];
+  }
+  return attachments.map((row) => {
+    if (!row || typeof row !== 'object' || Array.isArray(row)) {
+      throw new Error('Role assistant input.attachments entries must be objects');
+    }
+    const rel = row.path || row.file || row.filename;
+    const absolutePath = resolveRelativeAttachmentPath(caseDir, rel);
+    return attachmentFromFile(absolutePath, row);
+  });
+}
+
+function listOpenapiJsonFiles(absoluteDir, allowList) {
+  if (!fs.existsSync(absoluteDir)) {
+    throw new Error(`Role assistant openapiDir not found: ${absoluteDir}`);
+  }
+  const names = fs
+    .readdirSync(absoluteDir)
+    .filter((entry) => /\.json$/i.test(entry))
+    .sort();
+  if (Array.isArray(allowList) && allowList.length > 0) {
+    const wanted = new Set(allowList.map((row) => String(row).trim()).filter(Boolean));
+    return names.filter((name) => wanted.has(name));
+  }
+  return names;
+}
+
+function collectOpenapiDirAttachments(caseDir, input) {
+  if (typeof input.openapiDir !== 'string' || !input.openapiDir.trim()) {
+    return [];
+  }
+  const absoluteDir = path.resolve(caseDir, input.openapiDir.trim());
+  const files = listOpenapiJsonFiles(absoluteDir, input.openapiFiles);
+  if (files.length === 0) {
+    throw new Error(`Role assistant openapiDir has no matching *.json files: ${absoluteDir}`);
+  }
+  return files.map((name) => attachmentFromFile(path.join(absoluteDir, name), { role: 'openapi' }));
+}
+
+/**
+ * Build ATT-shaped attachments for work.start from case input.
+ * @param {Object} testCase - Normalized case (may include sourceFile)
+ * @returns {Object[]|undefined}
+ */
+function buildStartAttachments(testCase) {
+  const input =
+    testCase && typeof testCase.input === 'object' && testCase.input && !Array.isArray(testCase.input)
+      ? testCase.input
+      : {};
+  const caseDir = resolveCaseDirectory(testCase);
+  const fromExplicit = collectExplicitAttachments(caseDir, input.attachments);
+  const fromDir = collectOpenapiDirAttachments(caseDir, input);
+  const merged = [...fromExplicit, ...fromDir];
+  if (merged.length === 0) {
+    return undefined;
+  }
+  return merged;
+}
+
+module.exports = {
+  buildStartAttachments,
+  resolveCaseDirectory,
+  attachmentFromFile
+};

package/lib/role-assistant/test-runner-bid-apply.js

@@ -0,0 +1,201 @@
+/**
+ * Soft-loop BID apply after workspace.createsystem (suite 002 / plan 512.4).
+ * @fileoverview LAB-ONLY debt helper: POST Builder-api HTTP apply when the RA
+ * soft loop needs a package materialize. Product path is Decision Engine →
+ * capability.execute(template.applyintegrationdefinition) → COM/CIP.
+ * Do not treat this module as the product apply path once Runtime COM invoke
+ * works for the suite (plan 517.5). Non-product — lab helper only.
+ */
+
+'use strict';
+
+const fs = require('../internal/fs-real-sync');
+const path = require('path');
+const {
+  loadCaseBidDocument,
+  resolveTargetSystemKey
+} = require('./test-runner-bid-document');
+const { buildStartAttachments } = require('./test-runner-attachments');
+
+/**
+ * @returns {string}
+ */
+function resolveBuilderApiBaseUrl() {
+  const fromEnv = String(process.env.BUILDER_API_URL || process.env.BUILDER_URL || '').trim();
+  if (fromEnv) {
+    return fromEnv.replace(/\/$/, '');
+  }
+  let developerId = 0;
+  try {
+    const yaml = require('js-yaml');
+    const cfgPath = path.join(
+      process.env.HOME || '',
+      '.aifabrix',
+      'config.yaml'
+    );
+    if (fs.existsSync(cfgPath)) {
+      const cfg = yaml.load(fs.readFileSync(cfgPath, 'utf8')) || {};
+      developerId = Number(cfg['developer-id'] || cfg.developerId || 0) || 0;
+    }
+  } catch (_err) {
+    developerId = 0;
+  }
+  return `http://localhost:${3005 + developerId * 100}`;
+}
+
+/**
+ * @param {Object} authConfig
+ * @returns {string}
+ */
+function extractBearer(authConfig) {
+  if (!authConfig || typeof authConfig !== 'object') {
+    return '';
+  }
+  if (typeof authConfig.token === 'string' && authConfig.token.trim()) {
+    return authConfig.token.trim();
+  }
+  if (typeof authConfig.bearerToken === 'string' && authConfig.bearerToken.trim()) {
+    return authConfig.bearerToken.trim();
+  }
+  const header = authConfig.headers && authConfig.headers.Authorization;
+  const m = /^Bearer\s+(.+)$/i.exec(String(header || ''));
+  return m ? m[1].trim() : '';
+}
+
+/**
+ * True when wait is for template.applyintegrationdefinition and a case BID exists.
+ * @param {Object} testCase
+ * @param {Object} wait
+ * @returns {boolean}
+ */
+function shouldApplyBidAfterWait(testCase, wait) {
+  const bid = loadCaseBidDocument(testCase);
+  if (!bid) {
+    return false;
+  }
+  const capability = String(
+    wait.questionKey || wait.objectRef?.capabilityKey || wait.prompt || ''
+  ).toLowerCase();
+  // Product path: DE → capability.execute(template.applyintegrationdefinition).
+  return capability.includes('applyintegrationdefinition');
+}
+
+/**
+ * Lab-only soft HTTP BID apply. Hard cases (expected.soft !== true) must rely on
+ * Runtime COM/CIP apply after respond+continue — not Builder-api HTTP (517.5 / 517.4.7).
+ * @param {Object} testCase
+ * @param {Object} wait
+ * @returns {boolean}
+ */
+function shouldSoftHttpBidApply(testCase, wait) {
+  if (!shouldApplyBidAfterWait(testCase, wait)) {
+    return false;
+  }
+  return testCase?.expected?.soft === true;
+}
+
+/**
+ * @param {Object} testCase
+ * @returns {Object[]|null}
+ */
+function collectOpenApiPersistDocuments(testCase) {
+  let attachments = [];
+  try {
+    attachments = buildStartAttachments(testCase) || [];
+  } catch (_err) {
+    return null;
+  }
+  const documents = attachments
+    .filter((row) => row && (row.role === 'openapi' || !row.role) && row.body)
+    .map((row) => ({
+      filename: row.filename || row.name,
+      body: row.body
+    }))
+    .filter((row) => row.filename);
+  return documents.length > 0 ? documents : null;
+}
+
+/**
+ * @param {Response} res
+ * @param {string} label
+ * @returns {Promise<Object|null>}
+ */
+async function readBuilderApiJsonOrThrow(res, label) {
+  const text = await res.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch (_err) {
+    body = { raw: text };
+  }
+  if (!res.ok) {
+    const err = new Error(
+      `${label} HTTP ${res.status}: ${typeof body === 'object' ? JSON.stringify(body).slice(0, 300) : text}`
+    );
+    err.status = res.status;
+    throw err;
+  }
+  return body && body.data ? body.data : body;
+}
+
+/**
+ * Lab debt: stage suite OpenAPI into workspace via 517.2 persist API before apply.
+ * Product path is DE → capability.execute(persistsuppliedopenapi).
+ * @param {Object} authConfig
+ * @param {Object} testCase
+ * @param {string} systemKey
+ * @returns {Promise<Object|null>}
+ */
+async function persistCaseOpenApiViaBuilderApi(authConfig, testCase, systemKey) {
+  const token = extractBearer(authConfig);
+  if (!token || !systemKey) {
+    return null;
+  }
+  const documents = collectOpenApiPersistDocuments(testCase);
+  if (!documents) {
+    return null;
+  }
+  const url = `${resolveBuilderApiBaseUrl()}/api/v1/builder/systems/${encodeURIComponent(systemKey)}/openapi/persist-supplied`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ documents })
+  });
+  return readBuilderApiJsonOrThrow(res, 'OpenAPI persist failed');
+}
+
+/**
+ * @param {Object} authConfig
+ * @param {Object} testCase
+ * @returns {Promise<Object|null>}
+ */
+async function applyCaseBidViaBuilderApi(authConfig, testCase) {
+  const bid = loadCaseBidDocument(testCase);
+  const systemKey = resolveTargetSystemKey(testCase);
+  const token = extractBearer(authConfig);
+  if (!bid || !systemKey || !token) {
+    return null;
+  }
+  await persistCaseOpenApiViaBuilderApi(authConfig, testCase, systemKey);
+  const url = `${resolveBuilderApiBaseUrl()}/api/v1/builder/systems/${encodeURIComponent(systemKey)}/integration-definition/apply`;
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({ integrationDefinition: bid, force: true })
+  });
+  return readBuilderApiJsonOrThrow(res, 'BID apply failed');
+}
+
+module.exports = {
+  resolveBuilderApiBaseUrl,
+  shouldApplyBidAfterWait,
+  shouldSoftHttpBidApply,
+  persistCaseOpenApiViaBuilderApi,
+  applyCaseBidViaBuilderApi
+};