bdy 1.25.1-stage → 1.25.2-dev

package/distTs/src/command/yaml/actions/detect.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectActions = detectActions;
 const fs_1 = require("fs");
+const node_sea_1 = require("node:sea");
 const path_1 = __importDefault(require("path"));
 const picomatch_1 = __importDefault(require("picomatch"));
 const utils_1 = require("../../../utils");
@@ -15,8 +16,16 @@ let cachedRules = null;
 function loadDetectRules() {
     if (cachedRules)
         return cachedRules;
-    const filePath = path_1.default.resolve((0, utils_1.getRootDir)(), 'detect-rules.json');
-    cachedRules = JSON.parse((0, fs_1.readFileSync)(filePath, 'utf8'));
+    // Detection only feeds the "Suggested based on your repo" list, so a missing or
+    // unreadable rule file costs a suggestion rather than the command.
+    try {
+        cachedRules = JSON.parse((0, node_sea_1.isSea)()
+            ? (0, node_sea_1.getAsset)('detect-rules.json', 'utf8')
+            : (0, fs_1.readFileSync)(path_1.default.resolve((0, utils_1.getRootDir)(), 'detect-rules.json'), 'utf8'));
+    }
+    catch {
+        cachedRules = {};
+    }
     return cachedRules;
 }
 function safeReadDir(dir) {

package/distTs/src/command/yaml/actions/info.js

@@ -10,14 +10,16 @@ const schema_1 = require("./schema");
 const schemaUtils_1 = require("../schemaUtils");
 const detect_1 = require("./detect");
 const render_1 = require("../render");
+async function suggestionLine(query) {
+    return (await (0, schema_1.searchActions)(query, 5)).map((hit) => `${hit.type} (${hit.name})`);
+}
 const commandYamlActionsInfo = (0, utils_1.newCommand)('info', texts_1.DESC_COMMAND_YAML_ACTIONS_INFO);
 commandYamlActionsInfo.argument('<type>', texts_1.OPTION_ACTION_TYPE);
 commandYamlActionsInfo.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandYamlActionsInfo.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_YAML_ACTIONS_INFO}`);
 commandYamlActionsInfo.action(async (type, options) => {
     await (0, schemaUtils_1.ensureYamlSchema)();
-    const actions = (0, schema_1.loadSchema)();
-    const action = (0, schema_1.findAction)(actions, type);
+    const action = await (0, schema_1.findAction)(type);
     if (!action) {
         if (options.format === 'json') {
             output_1.default.json(null);
@@ -25,14 +27,16 @@ commandYamlActionsInfo.action(async (type, options) => {
             return;
         }
         output_1.default.error((0, texts_1.ERR_ACTION_NOT_FOUND)(type));
-        const suggestions = (0, schema_1.suggestActions)(actions, type);
+        const suggestions = await suggestionLine(type);
         if (suggestions.length > 0) {
-            output_1.default.muted((0, texts_1.TXT_ACTION_DID_YOU_MEAN)(suggestions.map((a) => `${a.type} (${a.name})`).join(', ')));
+            output_1.default.muted((0, texts_1.TXT_ACTION_DID_YOU_MEAN)(suggestions.join(', ')));
         }
         else {
             const detectedTypes = (0, detect_1.detectActions)(process.cwd());
             if (detectedTypes.size > 0) {
-                const detected = actions.filter((a) => detectedTypes.has(a.type)).slice(0, 5);
+                const detected = (await (0, schema_1.loadSchema)())
+                    .filter((a) => detectedTypes.has(a.type))
+                    .slice(0, 5);
                 output_1.default.muted((0, texts_1.TXT_ACTION_SUGGESTED_FROM_REPO)(detected.map((a) => `${a.type} (${a.name})`).join(', ')));
             }
         }
@@ -40,7 +44,7 @@ commandYamlActionsInfo.action(async (type, options) => {
         output_1.default.exitNormal();
         return;
     }
-    const { common, specific } = (0, schema_1.splitProperties)(action);
+    const { common, specific } = await (0, schema_1.splitProperties)(action);
     if (options.format === 'json') {
         output_1.default.json({
             type: action.type,
@@ -49,9 +53,10 @@ commandYamlActionsInfo.action(async (type, options) => {
             description: action.description,
             required: action.required,
             fields: {
-                specific: (0, render_1.propertiesJson)(specific, action.required),
-                common: (0, render_1.propertiesJson)(common, action.required),
+                specific: (0, render_1.propertiesJson)(specific),
+                common: (0, render_1.propertiesJson)(common),
             },
+            types: (0, render_1.typesJson)(action.types),
             examples: action.examples,
         });
         output_1.default.exitNormal();
@@ -61,14 +66,19 @@ commandYamlActionsInfo.action(async (type, options) => {
     output_1.default.gray(` · ${action.type}`);
     output_1.default.gray(action.description);
     output_1.default.normal('');
-    if (Object.keys(specific).length > 0) {
+    if (specific.length > 0) {
         output_1.default.blue('Type-specific fields');
-        (0, render_1.outputProperties)(specific, action.required);
+        (0, render_1.outputProperties)(specific);
         output_1.default.normal('');
     }
-    if (Object.keys(common).length > 0) {
+    if (common.length > 0) {
         output_1.default.blue('Common fields');
-        (0, render_1.outputProperties)(common, action.required);
+        (0, render_1.outputProperties)(common);
+    }
+    if (Object.keys(action.types).length > 0) {
+        output_1.default.normal('');
+        output_1.default.blue('Types');
+        (0, render_1.outputTypes)(action.types);
     }
     if (action.examples.length > 0) {
         output_1.default.normal('');

package/distTs/src/command/yaml/actions/list.js

@@ -12,9 +12,7 @@ const detect_1 = require("./detect");
 function actionTable(actions) {
     const data = [['TYPE', 'NAME', 'DESCRIPTION']];
     for (const action of actions) {
-        const desc = action.description.length > 80
-            ? action.description.substring(0, 77) + '...'
-            : action.description;
+        const desc = action.description.length > 80 ? `${action.description.substring(0, 77)}...` : action.description;
         data.push([action.type, action.name, desc]);
     }
     return data;
@@ -35,17 +33,14 @@ commandYamlActionsList.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandYamlActionsList.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_YAML_ACTIONS_LIST}`);
 commandYamlActionsList.action(async (options) => {
     await (0, schemaUtils_1.ensureYamlSchema)();
-    const actions = (0, schema_1.loadSchema)();
+    const actions = await (0, schema_1.loadSchema)();
     const detectedTypes = (0, detect_1.detectActions)(process.cwd());
+    const byType = new Map(actions.map((a) => [a.type, a]));
     if (options.search) {
-        const index = (0, schema_1.createActionIndex)(actions);
-        const hits = index.search(options.search);
-        const slugSet = new Set(hits.map((h) => h.id));
-        const results = actions.filter((a) => slugSet.has(a.slug));
-        results.sort((a, b) => {
-            const ai = hits.findIndex((h) => h.id === a.slug);
-            const bi = hits.findIndex((h) => h.id === b.slug);
-            return ai - bi;
+        const ranked = await (0, schema_1.searchActions)(options.search);
+        const results = ranked.flatMap((hit) => {
+            const action = byType.get(hit.type);
+            return action ? [action] : [];
         });
         if (results.length === 0) {
             if (options.format === 'json') {
@@ -53,11 +48,7 @@ commandYamlActionsList.action(async (options) => {
                 output_1.default.exitNormal();
                 return;
             }
-            const suggestions = index.autoSuggest(options.search);
             output_1.default.error((0, texts_1.ERR_ACTION_SEARCH_NO_RESULTS)(options.search));
-            if (suggestions.length > 0) {
-                output_1.default.muted((0, texts_1.TXT_ACTION_DID_YOU_MEAN)(suggestions.map((s) => s.suggestion).join(', ')));
-            }
             if (detectedTypes.size > 0) {
                 const detected = actions.filter((a) => detectedTypes.has(a.type));
                 output_1.default.normal('');
@@ -77,20 +68,20 @@ commandYamlActionsList.action(async (options) => {
         output_1.default.exitNormal();
         return;
     }
-    const byType = (a, b) => a.type.localeCompare(b.type);
+    const byTypeName = (a, b) => a.type.localeCompare(b.type);
     if (options.format === 'json') {
-        output_1.default.json(actionJson([...actions].sort(byType), detectedTypes));
+        output_1.default.json(actionJson([...actions].sort(byTypeName), detectedTypes));
         output_1.default.exitNormal();
         return;
     }
     if (detectedTypes.size > 0) {
-        const detected = actions.filter((a) => detectedTypes.has(a.type)).sort(byType);
+        const detected = actions.filter((a) => detectedTypes.has(a.type)).sort(byTypeName);
         output_1.default.blue('Suggested');
         output_1.default.table(actionTable(detected));
         output_1.default.normal('');
     }
     output_1.default.blue(`All actions (${actions.length})`);
-    output_1.default.table(actionTable([...actions].sort(byType)));
+    output_1.default.table(actionTable([...actions].sort(byTypeName)));
     output_1.default.exitNormal();
 });
 exports.default = commandYamlActionsList;

package/distTs/src/command/yaml/actions/schema.js

@@ -1,104 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadSchema = loadSchema;
-exports.getCommonFields = getCommonFields;
 exports.splitProperties = splitProperties;
 exports.findAction = findAction;
-exports.createActionIndex = createActionIndex;
-exports.suggestActions = suggestActions;
+exports.searchActions = searchActions;
 const schemaUtils_1 = require("../schemaUtils");
+const toActionDef = (member) => ({
+    key: member.definition,
+    slug: member.slug,
+    name: member.name,
+    type: member.value,
+    description: member.description,
+    properties: member.properties,
+    required: member.required,
+    examples: member.examples,
+    tags: member.tags,
+    types: member.document?.types ?? {},
+});
 let memCached = null;
-function deriveSlug(defKey) {
-    const base = defKey.replace(/ActionYaml$/, '');
-    return base
-        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
-        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
-        .toLowerCase();
-}
-function parseSchema(raw) {
-    const defs = raw.$defs || {};
-    const actionKeys = Object.keys(defs).filter((k) => k.endsWith('ActionYaml') && defs[k].deprecated !== true);
-    const sharedDefs = (0, schemaUtils_1.getSharedDefs)();
-    return actionKeys.map((key) => {
-        const def = defs[key];
-        const typeConst = def.properties?.type?.const || def.properties?.type?.enum?.[0] || '';
-        const properties = def.properties ? (0, schemaUtils_1.resolveRefs)(def.properties, sharedDefs) : {};
-        return {
-            key,
-            slug: deriveSlug(key),
-            name: def['x-name'] || def.title || key,
-            type: typeConst,
-            description: def.description || '',
-            properties,
-            required: def.required || [],
-            examples: def.examples || [],
-            tags: [...new Set([
-                    ...(def['x-tags'] || []),
-                    ...((def['x-subtypes'] || []).flatMap((s) => s['x-tags'] || [])),
-                ])],
-        };
-    });
-}
-function loadSchema() {
+async function loadSchema() {
     if (memCached)
         return memCached;
-    const raw = (0, schemaUtils_1.loadRawSchema)();
-    memCached = parseSchema(raw);
+    const scope = (0, schemaUtils_1.actionsScope)();
+    const members = await Promise.all((await scope.list()).map((type) => scope.get(type)));
+    memCached = members.filter((member) => member !== undefined).map(toActionDef);
     return memCached;
 }
-let commonCached = null;
-// Fields common to every action = intersection of property keys across all actions.
-function getCommonFields() {
-    if (commonCached)
-        return commonCached;
-    const actions = loadSchema();
-    let common = null;
-    for (const action of actions) {
-        const keys = Object.keys(action.properties);
-        if (common === null) {
-            common = new Set(keys);
-        }
-        else {
-            common = new Set(keys.filter((k) => common.has(k)));
-        }
-    }
-    commonCached = common || new Set();
-    return commonCached;
+async function getCommonFields() {
+    return new Set(await (0, schemaUtils_1.actionsScope)().commonFields());
 }
-function splitProperties(action) {
-    const commonFields = getCommonFields();
-    const common = {};
-    const specific = {};
-    for (const [key, prop] of Object.entries(action.properties)) {
-        if (commonFields.has(key))
-            common[key] = prop;
-        else
-            specific[key] = prop;
+async function splitProperties(action) {
+    const commonFields = await getCommonFields();
+    const common = [];
+    const specific = [];
+    for (const property of action.properties) {
+        (commonFields.has(property.name) ? common : specific).push(property);
     }
     return { common, specific };
 }
-function findAction(actions, query) {
-    const q = query.toLowerCase();
-    return (actions.find((a) => a.slug === q) ||
-        actions.find((a) => a.type.toLowerCase() === q));
-}
-function createActionIndex(actions) {
-    const MiniSearch = require('minisearch');
-    const index = new MiniSearch({
-        fields: ['name', 'type', 'description', 'tags'],
-        storeFields: ['slug'],
-        searchOptions: {
-            boost: { name: 3, type: 2, tags: 2, description: 1 },
-            prefix: true,
-            fuzzy: 0.3,
-            combineWith: 'OR',
-        },
-    });
-    index.addAll(actions.map((a) => ({ id: a.slug, name: a.name, type: a.type, description: a.description, tags: a.tags.join(' '), slug: a.slug })));
-    return index;
+async function findAction(query) {
+    const scope = (0, schemaUtils_1.actionsScope)();
+    const asked = query.toUpperCase();
+    const byType = (await scope.list()).find((type) => type === asked);
+    const member = byType ? await scope.get(byType) : await memberBySlug(query.toLowerCase());
+    return member && !member.deprecated ? toActionDef(member) : undefined;
+}
+async function memberBySlug(slug) {
+    const scope = (0, schemaUtils_1.actionsScope)();
+    for (const type of await scope.list()) {
+        const member = await scope.get(type);
+        if (member?.slug === slug)
+            return member;
+    }
+    return undefined;
 }
-function suggestActions(actions, query, limit = 5) {
-    const hits = createActionIndex(actions).search(query).slice(0, limit);
-    const bySlug = new Map(actions.map((a) => [a.slug, a]));
-    return hits.map((h) => bySlug.get(h.id)).filter(Boolean);
+async function searchActions(query, limit = Infinity) {
+    const hits = await (0, schemaUtils_1.actionsScope)().search(query, { fuzzy: 0.3, limit });
+    return hits.map((hit) => ({ type: hit.key, name: hit.name }));
 }

package/distTs/src/command/yaml/pipeline.js

@@ -8,44 +8,28 @@ const output_1 = __importDefault(require("../../output"));
 const texts_1 = require("../../texts");
 const schemaUtils_1 = require("./schemaUtils");
 const render_1 = require("./render");
-let cached = null;
-function loadPipelineRoot() {
-    if (cached)
-        return cached;
-    const defs = (0, schemaUtils_1.getAllDefs)();
-    const sharedDefs = (0, schemaUtils_1.getSharedDefs)();
-    const pipelineDef = defs['PipelineYaml'];
-    if (!pipelineDef?.properties) {
-        cached = { properties: {}, required: [], examples: [] };
-        return cached;
-    }
-    cached = {
-        properties: (0, schemaUtils_1.resolveRefs)(pipelineDef.properties, sharedDefs),
-        required: pipelineDef.required || [],
-        examples: pipelineDef.examples || [],
-    };
-    return cached;
-}
 const commandYamlPipeline = (0, utils_1.newCommand)('pipeline', texts_1.DESC_COMMAND_YAML_PIPELINE);
 commandYamlPipeline.option('--format <text|json>', texts_1.OPTION_FORMAT);
 commandYamlPipeline.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_YAML_PIPELINE}`);
 commandYamlPipeline.action(async (options) => {
     await (0, schemaUtils_1.ensureYamlSchema)();
-    const root = loadPipelineRoot();
+    const scope = (0, schemaUtils_1.pipelinesScope)();
+    const properties = await scope.properties('PipelineYaml');
+    const examples = ((await scope.root())?.examples ?? []);
     if (options.format === 'json') {
         output_1.default.json({
-            properties: (0, render_1.propertiesJson)(root.properties, root.required),
-            required: root.required,
-            examples: root.examples,
+            properties: (0, render_1.propertiesJson)(properties),
+            required: properties.filter((p) => p.required).map((p) => p.name),
+            examples,
         });
     }
     else {
         output_1.default.blue('Pipeline properties');
         output_1.default.normal('');
-        (0, render_1.outputProperties)(root.properties, root.required);
-        if (root.examples.length > 0) {
+        (0, render_1.outputProperties)(properties);
+        if (examples.length > 0) {
             output_1.default.normal('');
-            (0, render_1.outputExamples)(root.examples);
+            (0, render_1.outputExamples)(examples);
         }
     }
     output_1.default.exitNormal();

package/distTs/src/command/yaml/render.js

@@ -3,91 +3,103 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatType = formatType;
-exports.formatDescription = formatDescription;
 exports.propertiesJson = propertiesJson;
 exports.outputProperties = outputProperties;
+exports.typesJson = typesJson;
+exports.outputTypes = outputTypes;
 exports.outputExamples = outputExamples;
 const output_1 = __importDefault(require("../../output"));
-function formatType(prop) {
-    if (prop.const)
-        return `"${prop.const}"`;
-    if (prop.enum)
-        return 'enum';
-    if (prop.type === 'array') {
-        if (prop.items?.type)
-            return `${prop.items.type}[]`;
-        if (prop.items?.title)
-            return `${prop.items.title}[]`;
-        return 'array';
-    }
-    if (prop.type === 'object' && prop.properties)
-        return 'object';
-    return prop.type || 'any';
-}
-function formatDescription(prop) {
+const shownProperty = (prop) => prop;
+const shownField = (field) => ({
+    ...field,
+    minimum: field.constraints?.minimum,
+    maximum: field.constraints?.maximum,
+});
+const typeOf = (one) => (one.const !== undefined ? `"${one.const}"` : one.type);
+function describe(one) {
     const parts = [];
-    if (prop.description)
-        parts.push(prop.description);
-    if (prop.const)
-        parts.push(`Value: ${prop.const}`);
-    if (prop.enum)
-        parts.push(`Values: ${prop.enum.join(', ')}`);
-    if (prop.minimum !== undefined)
-        parts.push(`Min: ${prop.minimum}`);
-    if (prop.maximum !== undefined)
-        parts.push(`Max: ${prop.maximum}`);
+    if (one.description)
+        parts.push(one.description.replace(/\.$/, ''));
+    if (one.const !== undefined)
+        parts.push(`Value: ${one.const}`);
+    if (one.enum)
+        parts.push(`Values: ${one.enum.join(', ')}`);
+    if (one.minimum !== undefined)
+        parts.push(`Min: ${one.minimum}`);
+    if (one.maximum !== undefined)
+        parts.push(`Max: ${one.maximum}`);
     return parts.join('. ');
 }
-function sortedKeys(properties, required) {
-    return Object.keys(properties).sort((a, b) => {
-        const aReq = required.includes(a);
-        const bReq = required.includes(b);
-        if (aReq !== bReq)
-            return aReq ? -1 : 1;
-        return a.localeCompare(b);
-    });
-}
-// Not the raw sub-schema: resolveRefs inlines every nested def, which is 36KB for
-// trigger_conditions alone - a field every action carries.
-function propertiesJson(properties, required) {
-    const out = {};
-    for (const key of sortedKeys(properties, required)) {
-        const prop = properties[key];
-        const field = {
-            type: formatType(prop),
-            required: required.includes(key),
-        };
-        if (prop.description)
-            field.description = prop.description;
-        if (prop.const !== undefined)
-            field.const = prop.const;
-        if (prop.enum)
-            field.enum = prop.enum;
-        if (prop.minimum !== undefined)
-            field.minimum = prop.minimum;
-        if (prop.maximum !== undefined)
-            field.maximum = prop.maximum;
-        out[key] = field;
-    }
+function row(one) {
+    const out = { type: typeOf(one), required: one.required };
+    if (one.description)
+        out.description = one.description;
+    if (one.const !== undefined)
+        out.const = one.const;
+    if (one.enum)
+        out.enum = one.enum;
+    if (one.minimum !== undefined)
+        out.minimum = one.minimum;
+    if (one.maximum !== undefined)
+        out.maximum = one.maximum;
     return out;
 }
-function outputProperties(properties, required) {
-    const keys = sortedKeys(properties, required);
+function table(rows) {
     const data = [['FIELD', 'TYPE', 'REQUIRED', 'DESCRIPTION']];
-    for (const key of keys) {
-        const prop = properties[key];
-        const desc = formatDescription(prop);
-        const truncDesc = desc.length > 100 ? desc.substring(0, 97) + '...' : desc;
+    for (const one of rows) {
+        const desc = describe(one);
         data.push([
-            key,
-            formatType(prop),
-            required.includes(key) ? 'yes' : '',
-            truncDesc,
+            one.name,
+            typeOf(one),
+            one.required ? 'yes' : '',
+            desc.length > 100 ? `${desc.substring(0, 97)}...` : desc,
         ]);
     }
     output_1.default.table(data);
 }
+function sorted(properties) {
+    return properties.map(shownProperty).toSorted((a, b) => {
+        if (a.required !== b.required)
+            return a.required ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+}
+// Top level only: every action carries `trigger_conditions`, whose tree dwarfs its own fields.
+function propertiesJson(properties) {
+    const out = {};
+    for (const one of sorted(properties))
+        out[one.name] = row(one);
+    return out;
+}
+function outputProperties(properties) {
+    table(sorted(properties));
+}
+// A map's synthetic key row can be named after a real sibling field and read as its duplicate.
+const namedFields = (type) => type.fields.filter((one) => one.dynamicKey !== true).map(shownField);
+function typesJson(types) {
+    const out = {};
+    for (const [name, type] of Object.entries(types)) {
+        if (!type) {
+            out[name] = null;
+            continue;
+        }
+        const fields = {};
+        for (const one of namedFields(type))
+            fields[one.name] = row(one);
+        out[name] = fields;
+    }
+    return out;
+}
+function outputTypes(types) {
+    const named = Object.entries(types).filter((entry) => entry[1] !== null && entry[1].fields.length > 0);
+    if (named.length === 0)
+        return;
+    for (const [name, type] of named) {
+        output_1.default.normal('');
+        output_1.default.blue(name);
+        table(namedFields(type));
+    }
+}
 function formatExampleYaml(value) {
     try {
         const YAML = require('yaml');
@@ -105,7 +117,7 @@ function outputExamples(examples) {
     output_1.default.blue('Examples');
     for (const ex of examples) {
         output_1.default.normal('');
-        output_1.default.yellow(`# ${ex.title}`);
+        output_1.default.yellow(`# ${ex.title ?? 'Example'}`);
         output_1.default.gray(formatExampleYaml(ex.value));
     }
 }

package/distTs/src/command/yaml/schemaUtils.js

@@ -3,14 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipelinesScope = exports.actionsScope = void 0;
 exports.ensureYamlSchema = ensureYamlSchema;
 exports.loadRawSchema = loadRawSchema;
 exports.getDefValidator = getDefValidator;
 exports.validateAgainstDef = validateAgainstDef;
 exports.validateAgainstSchema = validateAgainstSchema;
 exports.getAllDefs = getAllDefs;
-exports.getSharedDefs = getSharedDefs;
-exports.resolveRefs = resolveRefs;
+const docs_schema_1 = require("@buddy-works/docs-schema");
 const utils_1 = require("../../utils");
 const input_1 = __importDefault(require("../../input"));
 const diskCache_1 = require("../../diskCache");
@@ -35,6 +35,16 @@ function readCachedSchema() {
         throw new Error((0, texts_1.ERR_YAML_SCHEMA_READ_FAILED)(path));
     return JSON.parse(raw);
 }
+let client = null;
+function schemas() {
+    if (!client)
+        client = docs_schema_1.BuddySchema.from({ pipelines: loadRawSchema() });
+    return client;
+}
+const actionsScope = () => schemas().actions;
+exports.actionsScope = actionsScope;
+const pipelinesScope = () => schemas().pipelines;
+exports.pipelinesScope = pipelinesScope;
 let cachedRaw = null;
 let ajvInstance = null;
 const validatorCache = new Map();
@@ -114,51 +124,3 @@ function getAllDefs() {
     const raw = loadRawSchema();
     return raw.$defs || {};
 }
-function getSharedDefs() {
-    const defs = getAllDefs();
-    const shared = {};
-    for (const [k, v] of Object.entries(defs)) {
-        if (!k.endsWith('ActionYaml')) {
-            shared[k] = v;
-        }
-    }
-    return shared;
-}
-function resolveRefs(properties, sharedDefs, depth = 0) {
-    if (depth > 5)
-        return properties;
-    const resolved = {};
-    for (const [key, prop] of Object.entries(properties)) {
-        if (prop.$ref) {
-            const refName = prop.$ref.replace('#/$defs/', '');
-            const refDef = sharedDefs[refName];
-            if (refDef) {
-                resolved[key] = { ...refDef, description: prop.description || refDef.description };
-                if (refDef.properties) {
-                    resolved[key].properties = resolveRefs(refDef.properties, sharedDefs, depth + 1);
-                }
-            }
-            else {
-                resolved[key] = prop;
-            }
-        }
-        else if (prop.type === 'array' && prop.items?.$ref) {
-            const refName = prop.items.$ref.replace('#/$defs/', '');
-            const refDef = sharedDefs[refName];
-            if (refDef) {
-                const resolvedItems = { ...refDef };
-                if (refDef.properties) {
-                    resolvedItems.properties = resolveRefs(refDef.properties, sharedDefs, depth + 1);
-                }
-                resolved[key] = { ...prop, items: resolvedItems };
-            }
-            else {
-                resolved[key] = prop;
-            }
-        }
-        else {
-            resolved[key] = prop;
-        }
-    }
-    return resolved;
-}