@aifabrix/builder 2.53.1 → 2.55.0

package/lib/search/search-display.js

@@ -0,0 +1,238 @@
+/**
+ * TTY table, JSON stdout, and --output file for search / skills.
+ *
+ * @fileoverview Search CLI display (no payload logging)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const chalk = require('chalk');
+const { formatBlockingError } = require('../utils/cli-layout-chalk');
+const { SearchCliError } = require('./search-errors');
+const { operationKeys, resourceTypesMap, isOperationRequired } = require('./search-skills');
+
+/**
+ * @param {string} filePath
+ * @param {Object} payload
+ * @param {{ existsSync: Function, writeFileSync: Function }} fsApi
+ */
+function writePayloadFile(filePath, payload, fsApi) {
+  const resolved = path.resolve(filePath);
+  const dir = path.dirname(resolved);
+  if (!fsApi.existsSync(dir)) {
+    throw new SearchCliError(`Output directory does not exist: ${dir}`);
+  }
+  try {
+    fsApi.writeFileSync(resolved, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  } catch (err) {
+    throw new SearchCliError(`Cannot write --output file: ${err.message || err}`);
+  }
+}
+
+/**
+ * @param {*} value
+ * @returns {string}
+ */
+function cellValue(value) {
+  if (value === null || value === undefined) {
+    return '';
+  }
+  if (typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+/**
+ * @param {string} text
+ * @param {number} width
+ * @returns {string}
+ */
+function padCell(text, width) {
+  const value = String(text ?? '');
+  if (value.length <= width) {
+    return value.padEnd(width);
+  }
+  if (width <= 1) {
+    return value.slice(0, width);
+  }
+  return `${value.slice(0, width - 1)}…`;
+}
+
+/**
+ * @param {Object[]} rows
+ * @param {string[]} [fieldList]
+ * @returns {string[]}
+ */
+function columnKeys(rows, fieldList) {
+  if (Array.isArray(fieldList) && fieldList.length) {
+    return fieldList;
+  }
+  const first = rows[0];
+  return first && typeof first === 'object' ? Object.keys(first) : [];
+}
+
+/**
+ * @param {Object} meta
+ * @param {Object[]} rows
+ * @returns {string}
+ */
+function formatHitsLine(meta, rows) {
+  const count = Array.isArray(rows) ? rows.length : 0;
+  const page = meta.currentPage || meta.page || 1;
+  const totalPages = meta.totalPages || 1;
+  const pageSize = meta.pageSize || count;
+  return `Hits    ${count}  page ${page}/${totalPages}  pageSize=${pageSize}`;
+}
+
+/**
+ * @param {Object} body
+ * @param {Object} payload
+ * @returns {string}
+ */
+function formatSearchHeader(body, payload) {
+  const meta = (payload && payload.meta) || {};
+  const resultMode = meta.resultMode || '';
+  const op = body.operation ? `  operation=${body.operation}` : '';
+  const mode = resultMode ? `  resultMode=${resultMode}` : '';
+  return `Search  role=${body.roleRef}  type=${body.resourceType}${op}${mode}`;
+}
+
+/**
+ * @param {Object[]} rows
+ * @param {string[]} keys
+ * @param {Object} log
+ */
+function printHitsTable(rows, keys, log) {
+  if (!keys.length) {
+    log.log('(no rows)');
+    return;
+  }
+  const widths = keys.map((key) =>
+    Math.min(
+      24,
+      Math.max(key.length, ...rows.map((row) => cellValue(row[key]).length), 4)
+    )
+  );
+  log.log(chalk.gray(keys.map((key, i) => padCell(key, widths[i])).join('  ')));
+  for (const row of rows) {
+    log.log(keys.map((key, i) => padCell(cellValue(row[key]), widths[i])).join('  '));
+  }
+}
+
+/**
+ * @param {Object} related
+ * @returns {string}
+ */
+function formatRelatedSummary(related) {
+  const parts = Object.keys(related).map((type) => {
+    const page = related[type];
+    const n = page && Array.isArray(page.data) ? page.data.length : 0;
+    return `${type} (${n})`;
+  });
+  return parts.length ? `Related  ${parts.join('  ')}` : '';
+}
+
+/**
+ * @param {Object} payload
+ * @param {Object} log
+ */
+function printSkillsTTY(payload, log) {
+  const typeMap = resourceTypesMap(payload);
+  const keys = Object.keys(typeMap);
+  if (!keys.length) {
+    log.log('No searchable resource types for this Role Assistant.');
+    return;
+  }
+  log.log(`Skills  role=${payload.roleRef || ''}`.trim());
+  for (const key of keys) {
+    const spec = typeMap[key] || {};
+    const ops = operationKeys(spec);
+    const req = isOperationRequired(spec) ? 'required' : 'optional';
+    const opText = ops.length ? ops.join(', ') : '(none)';
+    log.log(`  ${key}  operations=${opText}  operationRequired=${req}`);
+  }
+}
+
+/**
+ * @param {Object} opts
+ * @param {Object} payload
+ * @param {Object} log
+ * @param {{ existsSync: Function, writeFileSync: Function }} fsApi
+ */
+function emitPayload(opts, payload, log, fsApi) {
+  const json = opts.json === true;
+  if (opts.output) {
+    writePayloadFile(opts.output, payload, fsApi);
+  }
+  if (json) {
+    log.log(JSON.stringify(payload));
+  }
+}
+
+/**
+ * @param {Object} opts
+ * @param {Object} body
+ * @param {Object} payload
+ * @param {Object} log
+ * @param {Object} fsApi
+ */
+function emitSearchSuccess(opts, body, payload, log, fsApi) {
+  emitPayload(opts, payload, log, fsApi);
+  if (opts.json === true) {
+    return;
+  }
+  const rows = payload && Array.isArray(payload.data) ? payload.data : [];
+  const meta = (payload && payload.meta) || {};
+  log.log(formatSearchHeader(body, payload));
+  log.log(formatHitsLine(meta, rows));
+  printHitsTable(rows, columnKeys(rows, body.fields), log);
+  if (payload && payload.related && typeof payload.related === 'object') {
+    const summary = formatRelatedSummary(payload.related);
+    if (summary) log.log(summary);
+    if (opts.verbose === true) {
+      log.log(JSON.stringify(payload.related, null, 2));
+    }
+  }
+}
+
+/**
+ * @param {Object} opts
+ * @param {Object} payload
+ * @param {Object} log
+ * @param {Object} fsApi
+ */
+function emitSkillsSuccess(opts, payload, log, fsApi) {
+  emitPayload(opts, payload, log, fsApi);
+  if (opts.json !== true) {
+    printSkillsTTY(payload, log);
+  }
+}
+
+/**
+ * @param {Object} opts
+ * @param {string} message
+ * @param {Object} log
+ */
+function emitSearchError(opts, message, log) {
+  if (opts && opts.json === true) {
+    log.log(JSON.stringify({ error: message }));
+    return;
+  }
+  log.error(formatBlockingError(message));
+}
+
+module.exports = {
+  writePayloadFile,
+  cellValue,
+  columnKeys,
+  formatHitsLine,
+  formatSearchHeader,
+  formatRelatedSummary,
+  emitSearchSuccess,
+  emitSkillsSuccess,
+  emitSearchError
+};

package/lib/search/search-errors.js

@@ -0,0 +1,50 @@
+/**
+ * Exit codes and fail-closed errors for aifabrix search.
+ *
+ * @fileoverview Search CLI errors (auth = 3, other blocking = 1)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * @param {string} message
+ * @param {number} [exitCode]
+ */
+class SearchCliError extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = 'SearchCliError';
+    this.exitCode = exitCode;
+  }
+}
+
+/**
+ * @param {Error|SearchCliError|string} err
+ * @returns {number}
+ */
+function exitCodeForSearchError(err) {
+  if (Number.isInteger(err && err.exitCode) && err.exitCode > 0) {
+    return err.exitCode;
+  }
+  const message = String((err && err.message) || err);
+  if (/auth|login|token|unreachable/i.test(message)) {
+    return 3;
+  }
+  return 1;
+}
+
+/**
+ * @param {string} message
+ * @returns {SearchCliError}
+ */
+function authRequiredError(message) {
+  return new SearchCliError(message, 3);
+}
+
+module.exports = {
+  SearchCliError,
+  exitCodeForSearchError,
+  authRequiredError
+};

package/lib/search/search-prompts.js

@@ -0,0 +1,119 @@
+/**
+ * TTY inquirer lists for Role Assistant, resource type, and operation.
+ *
+ * @fileoverview Interactive pickers for aifabrix search (inject prompt in tests)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { SearchCliError } = require('./search-errors');
+const { listAssignedRoleAssistants } = require('./search-roles');
+const { operationKeys } = require('./search-skills');
+
+/**
+ * @param {Object} options
+ * @param {Function} [isTty]
+ * @returns {boolean}
+ */
+function isInteractive(options, isTty) {
+  if (options && options.json === true) {
+    return false;
+  }
+  if (options && options.interactive === false) {
+    return false;
+  }
+  const check = isTty || (() => Boolean(process.stdin && process.stdin.isTTY));
+  return Boolean(check());
+}
+
+/**
+ * @param {string[]} missing
+ * @returns {SearchCliError}
+ */
+function missingFlagsError(missing) {
+  const listed = missing.join(' and ');
+  return new SearchCliError(
+    `Missing ${listed}. Run in a terminal to pick, or pass ${listed}.`
+  );
+}
+
+/**
+ * @param {Function} prompt
+ * @param {string} name
+ * @param {string} message
+ * @param {Array<{ name: string, value: string }>} choices
+ * @returns {Promise<string>}
+ */
+async function promptList(prompt, name, message, choices) {
+  const ask = prompt || ((qs) => require('inquirer').prompt(qs));
+  const answers = await ask([
+    {
+      type: 'list',
+      name,
+      message,
+      choices
+    }
+  ]);
+  return String((answers && answers[name]) || '').trim();
+}
+
+/**
+ * @param {{ dataplaneUrl: string, authConfig: Object }} ctx
+ * @param {Object} deps
+ * @returns {Promise<string>}
+ */
+async function promptRoleAssistant(ctx, deps) {
+  const workers = await listAssignedRoleAssistants(
+    ctx.dataplaneUrl,
+    ctx.authConfig,
+    deps.getWorkRoles
+  );
+  if (!workers.length) {
+    throw new SearchCliError(
+      'No Role Assistants are assigned to your account.'
+    );
+  }
+  const choices = workers.map((row) => ({
+    name: `${row.key}  ${row.displayName}`,
+    value: row.key
+  }));
+  return promptList(deps.prompt, 'roleRef', 'Role Assistant', choices);
+}
+
+/**
+ * @param {string[]} typeKeys
+ * @param {Object} deps
+ * @returns {Promise<string>}
+ */
+async function promptResourceType(typeKeys, deps) {
+  if (!typeKeys.length) {
+    throw new SearchCliError('No searchable resource types for this Role Assistant.');
+  }
+  const choices = typeKeys.map((key) => ({ name: key, value: key }));
+  return promptList(deps.prompt, 'resourceType', 'Resource type', choices);
+}
+
+/**
+ * @param {Object} spec
+ * @param {Object} deps
+ * @returns {Promise<string>}
+ */
+async function promptOperation(spec, deps) {
+  const keys = operationKeys(spec);
+  if (!keys.length) {
+    return '';
+  }
+  const choices = keys.map((key) => ({ name: key, value: key }));
+  return promptList(deps.prompt, 'operation', 'Operation', choices);
+}
+
+module.exports = {
+  isInteractive,
+  missingFlagsError,
+  promptList,
+  promptRoleAssistant,
+  promptResourceType,
+  promptOperation
+};

package/lib/search/search-roles.js

@@ -0,0 +1,85 @@
+/**
+ * Role Assistants assigned to the current caller (work.roles).
+ *
+ * @fileoverview Parse work.roles for the search picker
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { SearchCliError } = require('./search-errors');
+
+/**
+ * @param {Object|Array|null|undefined} payload
+ * @returns {Object[]}
+ */
+function rolesArrayFromPayload(payload) {
+  let envelope = payload;
+  if (Array.isArray(envelope) && envelope.length === 1 && envelope[0] && typeof envelope[0] === 'object') {
+    envelope = envelope[0];
+  }
+  if (Array.isArray(envelope && envelope.roles)) {
+    return envelope.roles;
+  }
+  if (Array.isArray(envelope && envelope.data)) {
+    return envelope.data;
+  }
+  if (Array.isArray(envelope)) {
+    return envelope;
+  }
+  return [];
+}
+
+/**
+ * @param {Object} row
+ * @returns {{ key: string, displayName: string }|null}
+ */
+function asAssignedWorker(row) {
+  if (!row || typeof row !== 'object') {
+    return null;
+  }
+  if (row.availableToCaller === false) {
+    return null;
+  }
+  const key = String(row.roleRef || row.role_ref || row.key || '').trim();
+  if (!key) {
+    return null;
+  }
+  return { key, displayName: String(row.name || row.displayName || key).trim() };
+}
+
+/**
+ * @param {Object|Array|null|undefined} payload
+ * @returns {Array<{ key: string, displayName: string }>}
+ */
+function assignedWorkersFromPayload(payload) {
+  const workers = [];
+  for (const row of rolesArrayFromPayload(payload)) {
+    const worker = asAssignedWorker(row);
+    if (worker) workers.push(worker);
+  }
+  return workers;
+}
+
+/**
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {Function} getWorkRolesFn
+ * @returns {Promise<Array<{ key: string, displayName: string }>>}
+ */
+async function listAssignedRoleAssistants(dataplaneUrl, authConfig, getWorkRolesFn) {
+  const res = await getWorkRolesFn(dataplaneUrl, authConfig);
+  if (!res || Number(res.status) !== 200) {
+    const text = String((res && res.errorText) || '').trim();
+    throw new SearchCliError(text || 'Unable to list Role Assistants. Check login and try again.');
+  }
+  return assignedWorkersFromPayload(res.payload);
+}
+
+module.exports = {
+  rolesArrayFromPayload,
+  asAssignedWorker,
+  assignedWorkersFromPayload,
+  listAssignedRoleAssistants
+};