@aifabrix/builder 2.53.1 → 2.55.0

package/lib/commands/role-assistant.js

@@ -34,6 +34,12 @@ const {
   mergeCaseExecutionIntoLifecycleResult,
   lifecycleVerdictFromCaseExecution
 } = require('../role-assistant/test-runner');
+const { assertRoleAssistantEvidencePreflight } = require('../role-assistant/test-cases-evidence');
+const { assertLocalCasesBeforeAuth } = require('../role-assistant/test-case-validate');
+const {
+  loadPublishedTestsIntoOptions,
+  patchCaseStatusAfterRun
+} = require('../role-assistant/test-pack-sync');
 const { collectString } = require('./governance');
 const {
   sectionTitle,
@@ -49,11 +55,13 @@ const {
   bareRoleKey,
   roleAssistantSystemKey
 } = require('../utils/role-assistant-paths');
+const { registerRoleAssistantCopyCommand } = require('./role-assistant-copy');
 
 function roleAssistantGroupHelpAfter() {
   return `
 Subcommands:
   test <roleKey>   Run lifecycle checks, optional YAML cases/suites, and print a portal deep link
+  copy <roleKey>   Capture one Work Hub execution as a local YAML test case
 
 Package workspace (top-level commands — same digital-worker package):
   download / validate / upload / deploy <roleKey>   Manage role-assistant/ra-<roleKey>/
@@ -63,13 +71,16 @@ Examples:
   $ aifabrix role-assistant test customer-support-bot --suite 001
   $ aifabrix role-assistant test customer-support-bot --list-cases
   $ aifabrix role-assistant test customer-support-bot --env tst --json
+  $ aifabrix role-assistant copy customer-support-bot --suite 001 --reference a9f09fb8-d9eb-477f-8bb4-59e670fc82a4
   $ aifabrix upload customer-support-bot --env dev
   $ aifabrix test ra-customer-support-bot
 
 Notes:
   - Local packages live under role-assistant/ra-<roleKey>/ (bare <roleKey> in CLI args).
   - test uses the public/running worker by default; pass --publish (or upload) to refresh from local files.
+  - copy writes tests/<suite>/<caseId>.yaml from a Work Hub execution id; it does not publish.
   - See: aifabrix role-assistant test -h
+  - See: aifabrix role-assistant copy -h
 `;
 }
 
@@ -83,6 +94,7 @@ Examples:
   $ aifabrix role-assistant test customer-support-bot --suite 001
   $ aifabrix role-assistant test customer-support-bot --list-cases
   $ aifabrix role-assistant test customer-support-bot --suite 001 --fail-fast --json
+  $ aifabrix role-assistant test customer-support-bot --from-dataplane
   $ aifabrix test ra-customer-support-bot
 
 Notes:
@@ -91,8 +103,14 @@ Notes:
   - Use \`aifabrix upload <roleKey> --env …\` (or \`--publish\`) when you intentionally refresh the package.
   - Runs lifecycle checks, then prints a portal deep link for full step-by-step status.
   - Case files with input.message/input.content execute Work Hub plan→accept (or work.start when executionPath: intent).
+  - Cases with executionPath: search|skills (input.executionPath or case-root executionPath) run work.skills / work.search instead of Work Hub.
+  - After each case, current status is stored on the published test pack (passed, failed, or skipped).
+  - --from-dataplane loads published tests, then runs them (all suites unless --case / --suite is set).
+  - Role Assistant packages do not need application.yaml; test uses device login and the published dataplane worker.
+  - Cases with preflight.evidence.requiredKeys read live Evidence from the dataplane before start and hard-stop if those keys are missing or not active.
   - answers[] and approvals[] are matched to runtime wait payloads (questionKey/requestKey/waitReason).
   - --suite runs YAML under role-assistant/ra-<roleKey>/tests/<suite>/ (preferred), or tests/ra-<roleKey>/<roleKey>/<suite>/, or legacy tests/role-assistant/ra-<roleKey>/<suite>/ (override with --cases-root).
+  - --subject-email / --subject-user-id isolate Work Hub cases (repeatable). They do not generate Connected System governance packs and do not require application.yaml.
   - Use the portal URL for detailed human review while automation reads CLI/JSON output.
 `;
 }
@@ -133,6 +151,7 @@ function normalizeRoleAssistantTestOptions(options, cmd) {
     casesRoot: trimOptionalString(options.casesRoot),
     listCases: optionOrFlag(options, 'listCases', cmd, '--list-cases'),
     failFast: optionOrFlag(options, 'failFast', cmd, '--fail-fast'),
+    fromDataplane: optionOrFlag(options, 'fromDataplane', cmd, '--from-dataplane'),
     run: true
   };
 }
@@ -215,25 +234,38 @@ async function resolveSuiteCaseResults(systemKey, opts, result, verdict, portalU
   return outcomes;
 }
 
+async function maybeLoadFromDataplane(systemKey, opts) {
+  if (!opts.fromDataplane) {
+    return opts;
+  }
+  const auth = await resolveLifecycleAuth(systemKey, { ...opts, run: false, noPublish: true });
+  return loadPublishedTestsIntoOptions(systemKey, opts, auth);
+}
+
+async function resolveSelectedCaseResults(systemKey, opts, result, verdict, portalUrl) {
+  const runDiscovered = Boolean(opts.suite || (opts.fromDataplane && !opts.case));
+  if (runDiscovered) {
+    return resolveSuiteCaseResults(systemKey, opts, result, verdict, portalUrl);
+  }
+  return resolveRoleAssistantCaseResult(systemKey, opts, result, verdict, portalUrl);
+}
+
 async function runRoleAssistantTestAction(roleKey, options, cmd) {
-  const opts = normalizeRoleAssistantTestOptions(options, cmd);
+  let opts = normalizeRoleAssistantTestOptions(options, cmd);
   const systemKey = roleAssistantSystemKey(roleKey);
   const displayKey = bareRoleKey(roleKey);
+  opts = await maybeLoadFromDataplane(systemKey, opts);
 
   if (opts.listCases) {
     return listRoleAssistantCases(systemKey, opts);
   }
 
+  assertLocalCasesBeforeAuth(systemKey, opts);
+
   const result = await runLifecycleForExternalSystem(systemKey, opts);
   const verdict = lifecycleVerdictFromReport(result.report || {});
   const portalUrl = buildExternalSystemUiUrl(result.dataplaneUiBaseUrl, systemKey);
-
-  let caseResult = null;
-  if (opts.suite) {
-    caseResult = await resolveSuiteCaseResults(systemKey, opts, result, verdict, portalUrl);
-  } else {
-    caseResult = await resolveRoleAssistantCaseResult(systemKey, opts, result, verdict, portalUrl);
-  }
+  const caseResult = await resolveSelectedCaseResults(systemKey, opts, result, verdict, portalUrl);
 
   if (opts.json) {
     logger.log(
@@ -254,38 +286,96 @@ async function runRoleAssistantTestAction(roleKey, options, cmd) {
   return exitCode;
 }
 
-async function resolveRoleAssistantCaseResult(roleKey, opts, result, verdict, portalUrl) {
-  if (!opts.case) {
-    return null;
+async function patchPublishedCaseStatus(roleKey, opts, roleCase, evaluation, authContext) {
+  const caseId = roleCase && roleCase.caseId;
+  if (!caseId) {
+    return evaluation;
   }
-  const roleCase = loadRoleAssistantTestCase(roleKey, opts.case, {
-    testsDir: opts.testsDir || null
-  });
-  if (!isExecutableRoleAssistantCase(roleCase)) {
-    return evaluateRoleAssistantTestCase(roleCase, result, verdict, portalUrl);
+  let auth = authContext;
+  if (!auth || !auth.dataplaneUrl || !auth.authConfig) {
+    auth = await resolveLifecycleAuth(roleKey, { ...opts, run: false, noPublish: true });
+  }
+  if (!auth || !auth.dataplaneUrl || !auth.authConfig) {
+    return evaluation;
   }
+  await patchCaseStatusAfterRun({
+    systemKey: roleAssistantSystemKey(roleKey),
+    caseId,
+    evaluation,
+    dataplaneUrl: auth.dataplaneUrl,
+    authConfig: auth.authConfig
+  });
+  return evaluation;
+}
+
+function attachCaseExecution(evaluation, executionResult, error) {
+  const errMsg = error && (error.message || String(error));
+  evaluation.execution = {
+    processExecutionId: executionResult?.processExecutionId || error?.planId || null,
+    finalStatus: executionResult?.finalStatus?.status || (error ? 'failed' : null),
+    waitReason: executionResult?.finalStatus?.wait?.waitReason || null,
+    interactions: executionResult?.interactions || [],
+    workResultError: executionResult?.workResultError || errMsg || null
+  };
+  return evaluation;
+}
+
+async function resolveExecutableCaseResult(roleKey, roleCase, opts, result, verdict, portalUrl) {
   const authContext = await resolveLifecycleAuth(roleKey, {
     ...opts,
     run: false,
     noPublish: true
   });
+  const evidencePreflight = await assertRoleAssistantEvidencePreflight(roleCase, authContext);
   const executionResult = await runRoleAssistantCaseLifecycle(roleKey, roleCase, authContext, opts);
   const executionVerdict = lifecycleVerdictFromCaseExecution(executionResult, verdict);
   const evaluationInput = mergeCaseExecutionIntoLifecycleResult(result, executionResult);
+  evaluationInput.evidencePreflight = evidencePreflight;
   const evaluation = evaluateRoleAssistantTestCase(
     roleCase,
     evaluationInput,
     executionVerdict,
     portalUrl
   );
-  evaluation.execution = {
-    processExecutionId: executionResult.processExecutionId || null,
-    finalStatus: executionResult.finalStatus?.status || null,
-    waitReason: executionResult.finalStatus?.wait?.waitReason || null,
-    interactions: executionResult.interactions || [],
-    workResultError: executionResult.workResultError || null
-  };
-  return evaluation;
+  return attachCaseExecution(evaluation, executionResult);
+}
+
+async function resolveRoleAssistantCaseResult(roleKey, opts, result, verdict, portalUrl) {
+  if (!opts.case) {
+    return null;
+  }
+  const roleCase = loadRoleAssistantTestCase(roleKey, opts.case, {
+    testsDir: opts.testsDir || null
+  });
+  let evaluation;
+  if (!isExecutableRoleAssistantCase(roleCase)) {
+    evaluation = evaluateRoleAssistantTestCase(roleCase, result, verdict, portalUrl);
+  } else {
+    try {
+      evaluation = await resolveExecutableCaseResult(
+        roleKey,
+        roleCase,
+        opts,
+        result,
+        verdict,
+        portalUrl
+      );
+    } catch (error) {
+      const failedInput = mergeCaseExecutionIntoLifecycleResult(result, {
+        finalStatus: { status: 'failed' },
+        workResult: null,
+        workResultError: error.message || String(error),
+        interactions: []
+      });
+      failedInput.workResultError = error.message || String(error);
+      evaluation = attachCaseExecution(
+        evaluateRoleAssistantTestCase(roleCase, failedInput, verdict, portalUrl),
+        null,
+        error
+      );
+    }
+  }
+  return patchPublishedCaseStatus(roleKey, opts, roleCase, evaluation);
 }
 
 async function roleAssistantTestHandler(roleKey, options, cmd) {
@@ -297,19 +387,8 @@ async function roleAssistantTestHandler(roleKey, options, cmd) {
   }
 }
 
-function setupRoleAssistantCommands(program) {
-  const roleAssistant = program
-    .command('role-assistant')
-    .description(
-      'Role Assistant packages: lifecycle checks, YAML cases/suites, and portal deep links'
-    )
-    .addHelpText('after', roleAssistantGroupHelpAfter());
-
-  roleAssistant
-    .command('test <roleKey>')
-    .description(
-      'Lifecycle checks + optional cases/suites; prints portal deep link (bare <roleKey>)'
-    )
+function addRoleAssistantTestRunOptions(cmd) {
+  return cmd
     .option('-e, --env <env>', 'Environment: dev, tst, or pro', 'dev')
     .option('--case <caseIdOrPath>', 'Run and evaluate one role-assistant test case')
     .option('--tests-dir <dir>', 'Override role-assistant test case directory')
@@ -323,8 +402,16 @@ function setupRoleAssistantCommands(program) {
     )
     .option('--list-cases', 'List discoverable case files and exit')
     .option('--fail-fast', 'Stop suite run after the first failing case')
+    .option(
+      '--from-dataplane',
+      'Load published tests from the dataplane, then run them (all suites unless --case or --suite is set)'
+    )
     .option('-v, --verbose', 'Include full lifecycle report payload in --json output')
-    .option('-d, --debug', 'Write debug logs under role-assistant/<roleKey>/logs/')
+    .option('-d, --debug', 'Write debug logs under role-assistant/<roleKey>/logs/');
+}
+
+function addRoleAssistantTestPublishOptions(cmd) {
+  return cmd
     .option(
       '--publish',
       'Publish local Role Assistant package before checks (default: use public/running worker)'
@@ -332,24 +419,44 @@ function setupRoleAssistantCommands(program) {
     .option('--force', 'Force upload when --publish is set')
     .option(
       '--subject-user-id <id>',
-      'Subject user id for governance generate (repeatable)',
+      'Work Hub isolation user id (repeatable; not Connected System governance)',
       collectString,
       []
     )
     .option(
       '--subject-email <email>',
-      'Subject email for governance generate (repeatable)',
+      'Work Hub isolation email (repeatable; not Connected System governance)',
       collectString,
       []
     )
     .option(
       '--certification-profile <profile>',
-      'Certification profile for governance generate (bronze, silver, gold, ...)',
+      'Ignored for Role Assistant packages (Connected System governance generate does not run)',
       'bronze'
     )
-    .option('--json', 'Machine-readable output envelope')
+    .option('--json', 'Machine-readable output envelope');
+}
+
+function registerRoleAssistantTestCommand(roleAssistant) {
+  const cmd = roleAssistant
+    .command('test <roleKey>')
+    .description(
+      'Lifecycle checks + optional cases/suites; prints portal deep link (bare <roleKey>)'
+    );
+  addRoleAssistantTestPublishOptions(addRoleAssistantTestRunOptions(cmd))
     .addHelpText('after', roleAssistantHelpAfter())
-    .action((roleKey, options, cmd) => roleAssistantTestHandler(roleKey, options, cmd));
+    .action((roleKey, options, invoked) => roleAssistantTestHandler(roleKey, options, invoked));
+}
+
+function setupRoleAssistantCommands(program) {
+  const roleAssistant = program
+    .command('role-assistant')
+    .description(
+      'Role Assistant packages: lifecycle checks, YAML cases/suites, copy from Work Hub, and portal deep links'
+    )
+    .addHelpText('after', roleAssistantGroupHelpAfter());
+  registerRoleAssistantTestCommand(roleAssistant);
+  registerRoleAssistantCopyCommand(roleAssistant);
 }
 
 module.exports = {

package/lib/commands/search.js

@@ -0,0 +1,143 @@
+/**
+ * aifabrix search — retrieve governed Role Assistant information.
+ *
+ * @fileoverview Commander registration for search and search skills
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const { runSearch, runSearchSkills } = require('../search/search-run');
+const { exitCodeForSearchError } = require('../search/search-errors');
+const { emitSearchError } = require('../search/search-display');
+
+const SEARCH_HELP = `
+
+Examples:
+  $ aifabrix search
+  $ aifabrix search --role ra-cfo --resource-type customer
+  $ aifabrix search --role ra-cfo --resource-type customer --operation list --json
+  $ aifabrix search --role ra-cfo --resource-type customer --output ./search.json
+  $ aifabrix search skills --role ra-cfo
+`;
+
+const SKILLS_HELP = `
+
+Examples:
+  $ aifabrix search skills
+  $ aifabrix search skills --role ra-cfo
+  $ aifabrix search skills --role ra-cfo --json
+  $ aifabrix search skills --role ra-cfo --output ./skills.json
+`;
+
+/**
+ * @param {*} value
+ * @param {string[]} previous
+ * @returns {string[]}
+ */
+function collectKnowledgeKey(value, previous) {
+  const next = Array.isArray(previous) ? previous : [];
+  next.push(value);
+  return next;
+}
+
+/**
+ * @param {import('commander').Command} cmd
+ */
+function addSharedSearchOptions(cmd) {
+  cmd
+    .option('--role <roleRef>', 'Role Assistant key (for example ra-cfo)')
+    .option('--role-ref <roleRef>', 'Alias for --role')
+    .option('-o, --output <file>', 'Write the JSON payload to this file')
+    .option('--no-interactive', 'Never prompt; missing required flags fail')
+    .option('-e, --env <environment>', 'Environment key')
+    .option('--json', 'Print the JSON payload on stdout (no prompts)')
+    .option('-v, --verbose', 'Include extra TTY detail when available');
+}
+
+/**
+ * @param {import('commander').Command} cmd
+ */
+function addSearchBodyOptions(cmd) {
+  cmd
+    .option('--resource-type <key>', 'Resource type published on that Role Assistant')
+    .option('--type <key>', 'Alias for --resource-type')
+    .option('--operation <key>', 'Named operation for that resource type')
+    .option('--filters <json>', 'JSON object of field filters')
+    .option('--filters-file <path>', 'JSON object of field filters from a file')
+    .option('--page <n>', 'Page number (integer ≥ 1)')
+    .option('--page-size <n>', 'Page size (integer 1–100)')
+    .option('--sort <spec>', 'Sort specification (pass-through)')
+    .option('--fields <csv>', 'Comma-separated field names')
+    .option('--graph', 'Include one-level related records')
+    .option('--query <text>', 'Semantic hop text when --graph is set')
+    .option('--knowledge-key <key>', 'Knowledge key (repeatable)', collectKnowledgeKey, [])
+    .option('--body <file>', 'JSON request body file (merged after flags)');
+}
+
+/**
+ * @param {Function} action
+ * @param {Object} options
+ * @returns {Promise<void>}
+ */
+async function dispatchSearchLeaf(action, options) {
+  try {
+    const code = await action(options);
+    if (code && code !== 0) {
+      process.exit(code);
+    }
+  } catch (err) {
+    const message = err.message || String(err);
+    emitSearchError(options, message, logger);
+    process.exit(exitCodeForSearchError(err));
+  }
+}
+
+/**
+ * @param {Object} options
+ * @param {import('commander').Command} command
+ * @returns {Object}
+ */
+function mergeCommandOptions(options, command) {
+  const parentOpts =
+    command && command.parent && typeof command.parent.opts === 'function'
+      ? command.parent.opts()
+      : {};
+  return { ...parentOpts, ...options };
+}
+
+/**
+ * @param {import('commander').Command} program
+ */
+function setupSearchCommands(program) {
+  const search = program
+    .command('search')
+    .description('Search governed information for a Role Assistant assigned to you')
+    .addHelpText('after', SEARCH_HELP);
+  addSharedSearchOptions(search);
+  addSearchBodyOptions(search);
+
+  const searchRun = search
+    .command('run', { isDefault: true, hidden: true })
+    .description('Search governed information for a Role Assistant assigned to you')
+    .addHelpText('after', SEARCH_HELP);
+  searchRun.action(async(options, command) => {
+    await dispatchSearchLeaf(runSearch, mergeCommandOptions(options, command));
+  });
+
+  const skills = search
+    .command('skills')
+    .description('List searchable resource types and operations for a Role Assistant')
+    .addHelpText('after', SKILLS_HELP);
+  addSharedSearchOptions(skills);
+  skills.action(async(options, command) => {
+    await dispatchSearchLeaf(runSearchSkills, mergeCommandOptions(options, command));
+  });
+}
+
+module.exports = {
+  setupSearchCommands,
+  collectKnowledgeKey
+};