@aifabrix/builder 2.51.0 → 2.51.1

package/lib/utils/env-copy-keycloak.js

@@ -0,0 +1,196 @@
+/**
+ * Host .env.local Keycloak loopback URL helpers for env-copy.
+ *
+ * @fileoverview Resolve developer-scoped Keycloak ports for host-side .env.local
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const config = require('../core/config');
+
+/**
+ * Read unquoted env value from content.
+ * @param {string} content
+ * @param {string} key
+ * @returns {string}
+ */
+function readEnvLineValue(content, key) {
+  const re = new RegExp(`^${key}\\s*=\\s*(.*)$`, 'm');
+  const m = content.match(re);
+  if (!m) return '';
+  return m[1].trim().replace(/^["']|["']$/g, '');
+}
+
+/**
+ * @param {Object} cfgModule - Config module with CONFIG_FILE
+ * @returns {number|null}
+ */
+function readDeveloperIdFromConfig(cfgModule) {
+  const configPath = cfgModule && cfgModule.CONFIG_FILE ? cfgModule.CONFIG_FILE : null;
+  if (!configPath || !fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const cfgContent = fs.readFileSync(configPath, 'utf8');
+    const cfg = yaml.load(cfgContent) || {};
+    const raw = cfg['developer-id'];
+    if (typeof raw === 'number') {
+      return raw;
+    }
+    if (typeof raw === 'string' && /^[0-9]+$/.test(raw)) {
+      return parseInt(raw, 10);
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+/**
+ * Base Keycloak published port from urls.local.yaml (before developer offset).
+ * @returns {number|null}
+ */
+function readKeycloakBasePortFromUrlsLocal() {
+  try {
+    const urlsPath = path.join(path.dirname(config.CONFIG_FILE || ''), 'urls.local.yaml');
+    if (!fs.existsSync(urlsPath)) return null;
+    const doc = yaml.load(fs.readFileSync(urlsPath, 'utf8')) || {};
+    const raw = doc['keycloak-port'];
+    const n = typeof raw === 'number' ? raw : parseInt(String(raw || ''), 10);
+    return Number.isFinite(n) && n > 0 ? n : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} host
+ * @returns {string|null} Normalized loopback host or null when not loopback
+ */
+function normalizeKeycloakLoopbackHost(host) {
+  let next = host;
+  if (next === 'keycloak') {
+    next = 'localhost';
+  }
+  const isLoopback =
+    next === 'localhost' || next === '127.0.0.1' || next === '::1' || next === '[::1]';
+  if (!isLoopback) {
+    return null;
+  }
+  return next === '::1' ? '[::1]' : next;
+}
+
+/**
+ * @param {string} content
+ * @returns {number|null}
+ */
+function resolveExplicitKeycloakPort(content) {
+  const publicPortRaw = readEnvLineValue(content, 'KEYCLOAK_PUBLIC_PORT');
+  if (/^\d+$/.test(publicPortRaw)) {
+    return parseInt(publicPortRaw, 10);
+  }
+  const portRaw = readEnvLineValue(content, 'KEYCLOAK_PORT');
+  if (!/^\d+$/.test(portRaw)) {
+    return null;
+  }
+  const portNum = parseInt(portRaw, 10);
+  // 8080 is the in-container listen port — not the host publish port
+  return portNum !== 8080 ? portNum : null;
+}
+
+/**
+ * @returns {number|null}
+ */
+function resolveDeveloperIdForKeycloakPort() {
+  try {
+    const raw = process.env.AIFABRIX_DEVELOPERID;
+    if (raw && /^[0-9]+$/.test(String(raw).trim())) {
+      return parseInt(String(raw).trim(), 10);
+    }
+    return readDeveloperIdFromConfig(config);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Published Keycloak host port for this developer (never a fixed 8182).
+ * Prefer KEYCLOAK_PUBLIC_PORT, then loopback KEYCLOAK_PORT (if not container 8080),
+ * else base from urls.local.yaml / 8082 + developer-id × 100.
+ *
+ * @param {string} content - Env file content
+ * @returns {{ host: string, port: number }|null}
+ */
+function resolveHostKeycloakLoopbackEndpoint(content) {
+  const { publishedHostPort, parseDeveloperIdNum } = require('./declarative-url-ports');
+  const host = normalizeKeycloakLoopbackHost(
+    readEnvLineValue(content, 'KEYCLOAK_HOST') || 'localhost'
+  );
+  if (!host) {
+    return null;
+  }
+  const explicit = resolveExplicitKeycloakPort(content);
+  if (explicit !== null) {
+    return { host, port: explicit };
+  }
+  const base = readKeycloakBasePortFromUrlsLocal() || 8082;
+  const port = publishedHostPort(base, parseDeveloperIdNum(resolveDeveloperIdForKeycloakPort()));
+  return { host, port };
+}
+
+/**
+ * Upsert KEYCLOAK_PORT and KEYCLOAK_INTERNAL_SERVER_URL for host .env.local.
+ * @param {string} content
+ * @param {string} host
+ * @param {number} port
+ * @returns {string}
+ */
+function patchKeycloakHostInternalLines(content, host, port) {
+  const internalUrl = `http://${host}:${port}/auth`;
+  let next = content;
+  if (readEnvLineValue(content, 'KEYCLOAK_HOST') === 'keycloak') {
+    next = next.replace(/^KEYCLOAK_HOST\s*=.*$/m, 'KEYCLOAK_HOST=localhost');
+  }
+  if (/^KEYCLOAK_PORT\s*=/m.test(next)) {
+    next = next.replace(/^KEYCLOAK_PORT\s*=.*$/m, `KEYCLOAK_PORT=${port}`);
+  } else {
+    next = `${next.trimEnd()}\nKEYCLOAK_PORT=${port}\n`;
+  }
+  if (/^KEYCLOAK_INTERNAL_SERVER_URL\s*=/m.test(next)) {
+    return next.replace(
+      /^KEYCLOAK_INTERNAL_SERVER_URL\s*=.*$/m,
+      `KEYCLOAK_INTERNAL_SERVER_URL=${internalUrl}`
+    );
+  }
+  return `${next.trimEnd()}\nKEYCLOAK_INTERNAL_SERVER_URL=${internalUrl}\n`;
+}
+
+/**
+ * For host `.env.local`, force Keycloak admin/internal base to this developer's
+ * published loopback port (`base + developerId × 100`). Never hardcodes a single
+ * developer’s port (e.g. 8182).
+ *
+ * @param {string} content - Env file content
+ * @returns {string}
+ */
+function applyHostLocalKeycloakInternalUrl(content) {
+  if (typeof content !== 'string' || content.length === 0) {
+    return content;
+  }
+  const endpoint = resolveHostKeycloakLoopbackEndpoint(content);
+  if (!endpoint) {
+    return content;
+  }
+  return patchKeycloakHostInternalLines(content, endpoint.host, endpoint.port);
+}
+
+module.exports = {
+  applyHostLocalKeycloakInternalUrl,
+  readEnvLineValue,
+  resolveHostKeycloakLoopbackEndpoint
+};

package/lib/utils/env-copy.js

@@ -21,6 +21,7 @@ const { rewriteInfraEndpoints } = require('./env-endpoints');
 const { buildEnvVarMap } = require('./env-map');
 const { interpolateEnvVars } = require('./secrets-helpers');
 const { getLocalPort } = require('./port-resolver');
+const { applyHostLocalKeycloakInternalUrl } = require('./env-copy-keycloak');
 
 /**
  * Read developer ID from config file synchronously
@@ -98,6 +99,26 @@ function resolveEnvOutputPath(rawOutputPath, variablesPath) {
   return outputPath;
 }
 
+/**
+ * Sibling host-only env path next to `build.envOutputPath` (`.env` → `.env.local`).
+ * Used for host CLI / manual tests; must not be mounted into the container.
+ *
+ * @param {string} envOutputPath - Resolved path ending in `.env`
+ * @returns {string} Path ending in `.env.local`
+ */
+function resolveEnvLocalOutputPath(envOutputPath) {
+  if (typeof envOutputPath !== 'string' || envOutputPath.trim() === '') {
+    throw new Error('envOutputPath is required to resolve .env.local');
+  }
+  if (envOutputPath.endsWith('.env.local')) {
+    return envOutputPath;
+  }
+  if (envOutputPath.endsWith('.env')) {
+    return `${envOutputPath}.local`;
+  }
+  return path.join(path.dirname(envOutputPath), '.env.local');
+}
+
 /**
  * Writes .env to envOutputPath for `--reload`: merge container `.env.run` into the host file.
  * Preserves comments when a file already exists (e.g. after `aifabrix resolve`). Keys present only
@@ -149,8 +170,18 @@ async function writeEnvOutputForLocal(appName, outputPath) {
     const localMap = parseEnvContentToMap(localContent);
     toWrite = mergeEnvMapIntoContent(existingContent, localMap);
   }
+  const isLocalSibling = path.basename(outputPath) === '.env.local';
+  if (isLocalSibling) {
+    toWrite = applyHostLocalKeycloakInternalUrl(toWrite);
+  }
   await fsp.writeFile(outputPath, toWrite, { mode: 0o600 });
-  logger.log(formatSuccessLine(`Wrote .env to envOutputPath (localPort): ${outputPath}`));
+  logger.log(
+    formatSuccessLine(
+      isLocalSibling
+        ? `Wrote host .env.local (localhost ports for CLI/tests): ${outputPath}`
+        : `Wrote .env to envOutputPath (localPort): ${outputPath}`
+    )
+  );
 }
 
 /**
@@ -408,6 +439,8 @@ async function processEnvVariables(envPath, variablesPath, appName, secretsPath,
 module.exports = {
   processEnvVariables,
   resolveEnvOutputPath,
+  resolveEnvLocalOutputPath,
+  applyHostLocalKeycloakInternalUrl,
   substituteMntDataForLocal,
   syncWrittenBuilderEnvToOutputPath,
   writeEnvOutputForReload,

package/lib/utils/external-system-readiness-compact-display.js

@@ -248,6 +248,9 @@ function formatGatePillarLine(opts = {}) {
   if (verdict === VERDICT.FAILED) {
     return formatBlockingError(`${label} · FAILED${suffix}`);
   }
+  if (verdict === VERDICT.NOT_APPLICABLE) {
+    return formatSuccessLine(`${label} · NOT APPLICABLE${suffix}`);
+  }
   return formatWarningLine(`${label} · NOT VERIFIED${suffix}`);
 }
 

package/lib/utils/help-builder.js

@@ -79,6 +79,7 @@ const CATEGORIES = [
       { name: 'dimension value', term: 'dimension value <command>' },
       { name: 'resource-type' },
       { name: 'role' },
+      { name: 'role-assistant' },
       { name: 'evidence-kind' },
       { name: 'enterprise-knowledge' },
       { name: 'identity' },

package/lib/utils/paths.js

@@ -382,15 +382,41 @@ function getIntegrationBuilderBaseDir() {
 }
 
 /**
- * Returns the default integration root under {@link getAppsMaterializationParent} (listing may also
- * scan {@link getCwdIntegrationRoot}; see {@link listIntegrationAppNames}).
+ * Returns the default integration root: {@link getCwdIntegrationRoot} when present, else
+ * under {@link getAppsMaterializationParent}. Listing may still scan both trees
+ * (see {@link listIntegrationAppNames}).
  *
  * @returns {string} Absolute path to integration/ directory
  */
 function getIntegrationRoot() {
+  const cwdRoot = getCwdIntegrationRoot();
+  if (cwdRoot) {
+    return cwdRoot;
+  }
   return path.join(getAppsMaterializationParent(), 'integration');
 }
 
+/**
+ * True when path exists and is a directory (best-effort; false on error).
+ * @param {string} dirPath
+ * @returns {boolean}
+ */
+function isExistingDirectoryPath(dirPath) {
+  if (!dirPath || typeof dirPath !== 'string') {
+    return false;
+  }
+  try {
+    const disk = nodeFs();
+    if (!disk.existsSync(dirPath)) {
+      return false;
+    }
+    const st = disk.statSync(dirPath);
+    return Boolean(st && typeof st.isDirectory === 'function' && st.isDirectory());
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Absolute `integration/` next to {@link process.cwd} when that directory exists.
  *
@@ -574,8 +600,10 @@ function listIntegrationAppNames() {
   if (cwdRoot) {
     addBuilderSubdirNamesToSet(disk, cwdRoot, names, withAppConfig(cwdRoot));
   }
-  const matInt = getIntegrationRoot();
-  addBuilderSubdirNamesToSet(disk, matInt, names, withAppConfig(matInt));
+  const matInt = path.join(getAppsMaterializationParent(), 'integration');
+  if (!cwdRoot || path.resolve(matInt) !== path.resolve(cwdRoot)) {
+    addBuilderSubdirNamesToSet(disk, matInt, names, withAppConfig(matInt));
+  }
   return [...names].sort();
 }
 
@@ -629,8 +657,11 @@ function listBuilderAppNames() {
 }
 
 /**
- * Gets the integration folder path: **`cwd/integration/<appName>`** when that directory exists, else
- * **`aifabrix-work` or `aifabrix-home` + `/integration/<appName>`**.
+ * Gets the integration folder path.
+ * Resolution: existing `cwd/integration/<app>` → existing materialization copy →
+ * `cwd/integration/<app>` when `cwd/integration/` exists (new download/create) →
+ * materialization parent. Download should use {@link getAppCreatePath} when it must
+ * always land under cwd even if a materialization orphan exists.
  *
  * @param {string} appName - Application name
  * @returns {string} Absolute path to integration directory
@@ -648,18 +679,21 @@ function getIntegrationPath(appName) {
   } catch {
     // programmatic module optional for CLI-only usage
   }
-  const cwdInt = path.join(path.resolve(process.cwd()), 'integration', appName);
-  try {
-    if (nodeFs().existsSync(cwdInt)) {
-      const st = nodeFs().statSync(cwdInt);
-      if (st && typeof st.isDirectory === 'function' && st.isDirectory()) {
-        return cwdInt;
-      }
+  const cwdRoot = getCwdIntegrationRoot();
+  const matApp = path.join(getAppsMaterializationParent(), 'integration', appName);
+  if (cwdRoot) {
+    const cwdApp = path.join(cwdRoot, appName);
+    if (isExistingDirectoryPath(cwdApp)) {
+      return cwdApp;
     }
-  } catch {
-    // ignore
   }
-  return path.join(getAppsMaterializationParent(), 'integration', appName);
+  if (isExistingDirectoryPath(matApp)) {
+    return matApp;
+  }
+  if (cwdRoot) {
+    return path.join(cwdRoot, appName);
+  }
+  return matApp;
 }
 
 /**
@@ -797,13 +831,15 @@ function resolveExistingWorkspacePath(appName, options) {
   if (isExistingAppDirectory(appPath)) {
     return { appPath, baseDir };
   }
-  const altWorkspace =
-    baseDir === 'enterprise-knowledge' ? 'integration' : 'enterprise-knowledge';
-  const alt = resolveAppWorkspace(appName, { ...options, workspace: altWorkspace });
-  if (!isExistingAppDirectory(alt.appPath)) {
-    return null;
+  const alternates = ['integration', 'enterprise-knowledge', 'role-assistant']
+    .filter((workspaceName) => workspaceName !== baseDir);
+  for (const workspaceName of alternates) {
+    const alt = resolveAppWorkspace(appName, { ...options, workspace: workspaceName });
+    if (isExistingAppDirectory(alt.appPath)) {
+      return { appPath: alt.appPath, baseDir: alt.baseDir };
+    }
   }
-  return { appPath: alt.appPath, baseDir: alt.baseDir };
+  return null;
 }
 
 function externalWorkspaceFolderFromConfig(appPath, baseDir, scopedWorkspace) {
@@ -926,7 +962,7 @@ async function detectAppType(appName, options = {}) {
   const builderAfterTemplate = checkBuilderFolder(appName);
   if (builderAfterTemplate) return builderAfterTemplate;
   throw new Error(
-    `App '${appName}' not found in integration/${appName}, enterprise-knowledge/${appName}, or builder/${appName}`
+    `App '${appName}' not found in integration/${appName}, enterprise-knowledge/${appName}, role-assistant/${appName}, or builder/${appName}`
   );
 }
 
@@ -964,6 +1000,11 @@ async function getResolveAppPath(appName, options = {}) {
   if (workspaceHit) {
     return workspaceHit;
   }
+  const { getRoleAssistantPath } = require('./role-assistant-paths');
+  const roleAssistantHit = tryResolveEnvOnlyPath(getRoleAssistantPath(appName));
+  if (roleAssistantHit) {
+    return roleAssistantHit;
+  }
   const integrationHit = tryResolveEnvOnlyPath(getIntegrationPath(appName));
   if (integrationHit) {
     return integrationHit;
@@ -1073,6 +1114,9 @@ module.exports = {
   getEnterpriseKnowledgePath: require('./enterprise-knowledge-paths').getEnterpriseKnowledgePath,
   getEnterpriseKnowledgeRoot: require('./enterprise-knowledge-paths').getEnterpriseKnowledgeRoot,
   listEnterpriseKnowledgeAnchors: require('./enterprise-knowledge-paths').listEnterpriseKnowledgeAnchors,
+  getRoleAssistantPath: require('./role-assistant-paths').getRoleAssistantPath,
+  getRoleAssistantRoot: require('./role-assistant-paths').getRoleAssistantRoot,
+  getCwdRoleAssistantRoot: require('./role-assistant-paths').getCwdRoleAssistantRoot,
   resolveAppWorkspace: require('./app-path-resolve').resolveAppWorkspace,
   resolveExternalSystemPath: require('./app-path-resolve').resolveExternalSystemPath
 };

package/lib/utils/pipeline-upload-auth-retry.js

@@ -57,10 +57,22 @@ async function resolveClientTokenAuthForPipelineRetry(systemKey) {
  * @param {Object} authConfig
  * @param {Object} payload
  * @param {string} systemKey - External system key for credential lookup on retry
+ * @param {Object} [options] - Forwarded to uploadApplicationViaPipeline (e.g. timeoutMs)
  * @returns {Promise<Object>}
  */
-async function uploadApplicationViaPipelineWithAuthRetry(dataplaneUrl, authConfig, payload, systemKey) {
-  const first = await uploadApplicationViaPipeline(dataplaneUrl, authConfig, payload);
+async function uploadApplicationViaPipelineWithAuthRetry(
+  dataplaneUrl,
+  authConfig,
+  payload,
+  systemKey,
+  options = {}
+) {
+  const first = await uploadApplicationViaPipeline(
+    dataplaneUrl,
+    authConfig,
+    payload,
+    options
+  );
   if (!isPipelineAuthFailure(first) || authConfig.type !== 'bearer') {
     return first;
   }
@@ -77,7 +89,7 @@ async function uploadApplicationViaPipelineWithAuthRetry(dataplaneUrl, authConfi
       'Device login token was rejected for pipeline publish; retrying with application client token…'
     )
   );
-  return uploadApplicationViaPipeline(dataplaneUrl, clientAuth, payload);
+  return uploadApplicationViaPipeline(dataplaneUrl, clientAuth, payload, options);
 }
 
 module.exports = {

package/lib/utils/role-assistant-paths.js

@@ -0,0 +1,98 @@
+/**
+ * Role Assistant workspace path helpers.
+ *
+ * @fileoverview Paths under role-assistant/ for Role Assistant packages
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const { nodeFs } = require('../internal/node-fs');
+
+const WORKSPACE_ROLE_ASSISTANT = 'role-assistant';
+const SYSTEM_KIND_DIGITAL_WORKER = 'digitalWorker';
+
+function getMaterializationParent() {
+  const work = process.env.AIFABRIX_WORK;
+  if (work && typeof work === 'string' && work.trim()) {
+    return path.resolve(work.trim());
+  }
+  if (process.env.AIFABRIX_HOME && typeof process.env.AIFABRIX_HOME === 'string') {
+    return path.resolve(process.env.AIFABRIX_HOME.trim());
+  }
+  return path.join(os.homedir(), '.aifabrix');
+}
+
+function getCwdRoleAssistantRoot() {
+  const p = path.join(path.resolve(process.cwd()), WORKSPACE_ROLE_ASSISTANT);
+  try {
+    const disk = nodeFs();
+    if (disk.existsSync(p)) {
+      const st = disk.statSync(p);
+      if (st && typeof st.isDirectory === 'function' && st.isDirectory()) {
+        return p;
+      }
+    }
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+function getRoleAssistantRoot() {
+  const cwdRoot = getCwdRoleAssistantRoot();
+  if (cwdRoot) {
+    return cwdRoot;
+  }
+  return path.join(getMaterializationParent(), WORKSPACE_ROLE_ASSISTANT);
+}
+
+function isExistingDirectory(disk, dirPath) {
+  try {
+    if (!dirPath || !disk.existsSync(dirPath)) {
+      return false;
+    }
+    const st = disk.statSync(dirPath);
+    return Boolean(st && typeof st.isDirectory === 'function' && st.isDirectory());
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Resolves role-assistant/<roleKey> with cwd-first behavior.
+ * @param {string} roleKey
+ * @returns {string}
+ */
+function getRoleAssistantPath(roleKey) {
+  if (!roleKey || typeof roleKey !== 'string') {
+    throw new Error('Role key is required and must be a string');
+  }
+  const disk = nodeFs();
+  const cwdRoot = getCwdRoleAssistantRoot();
+  const matPath = path.join(getMaterializationParent(), WORKSPACE_ROLE_ASSISTANT, roleKey);
+  if (cwdRoot) {
+    const cwdPath = path.join(cwdRoot, roleKey);
+    if (isExistingDirectory(disk, cwdPath)) {
+      return cwdPath;
+    }
+  }
+  if (isExistingDirectory(disk, matPath)) {
+    return matPath;
+  }
+  if (cwdRoot) {
+    return path.join(cwdRoot, roleKey);
+  }
+  return matPath;
+}
+
+module.exports = {
+  WORKSPACE_ROLE_ASSISTANT,
+  SYSTEM_KIND_DIGITAL_WORKER,
+  getCwdRoleAssistantRoot,
+  getRoleAssistantRoot,
+  getRoleAssistantPath
+};

package/lib/utils/schema-loader.js

@@ -18,6 +18,7 @@ const addFormats = require('ajv-formats');
 // These are reset when module is reloaded (for testing)
 let externalSystemValidator = null;
 let externalDataSourceValidator = null;
+let roleAssistantSettingsValidator = null;
 
 /**
  * Reset validators cache (for testing)
@@ -26,6 +27,7 @@ let externalDataSourceValidator = null;
 function resetValidators() {
   externalSystemValidator = null;
   externalDataSourceValidator = null;
+  roleAssistantSettingsValidator = null;
 }
 
 /**
@@ -138,6 +140,38 @@ function loadExternalDataSourceSchema() {
   return externalDataSourceValidator;
 }
 
+/**
+ * Loads and compiles role-assistant settings schema.
+ * @function loadRoleAssistantSettingsSchema
+ * @returns {Function}
+ */
+function loadRoleAssistantSettingsSchema() {
+  if (roleAssistantSettingsValidator) {
+    return roleAssistantSettingsValidator;
+  }
+
+  const schemaPath = path.join(__dirname, '..', 'schema', 'role-assistant-settings.schema.json');
+  let schema;
+  try {
+    const schemaContent = fsRealSync.readFileSync(schemaPath, 'utf8');
+    schema = JSON.parse(schemaContent);
+  } catch (error) {
+    try {
+      schema = require('../schema/role-assistant-settings.schema.json');
+    } catch {
+      if (error && error.code === 'ENOENT') {
+        throw new Error(`Role assistant settings schema not found: ${schemaPath}`);
+      }
+      throw new Error(`Invalid JSON in role-assistant-settings.schema.json: ${error.message}`);
+    }
+  }
+
+  const ajv = new Ajv({ allErrors: true, strict: false, strictSchema: false });
+  addFormats(ajv);
+  roleAssistantSettingsValidator = ajv.compile(schema);
+  return roleAssistantSettingsValidator;
+}
+
 /**
  * Detect schema type from $id field
  * @param {Object} parsed - Parsed JSON object
@@ -157,6 +191,9 @@ function detectFromId(parsed) {
   if (parsed.$id.includes('application-schema')) {
     return 'application';
   }
+  if (parsed.$id.includes('role-assistant-settings')) {
+    return 'role-assistant-settings';
+  }
 
   return null;
 }
@@ -239,6 +276,9 @@ function detectFromApplicationFields(parsed) {
  */
 function detectFromFilename(filePath) {
   const fileName = path.basename(filePath).toLowerCase();
+  if (fileName === 'role-assistant.yaml' || fileName === 'role-assistant.yml') {
+    return 'role-assistant-settings';
+  }
   if (fileName.includes('external-system') || fileName.includes('external_system')) {
     return 'external-system';
   }
@@ -347,6 +387,7 @@ function detectSchemaType(filePath, content) {
 module.exports = {
   loadExternalSystemSchema,
   loadExternalDataSourceSchema,
+  loadRoleAssistantSettingsSchema,
   registerExternalDatasourceAjvDependencies,
   detectSchemaType,
   detectSchemaTypeFromParsed,