bdy 1.24.8 → 1.25.0-dev

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

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const output_1 = __importDefault(require("../../../output"));
+const texts_1 = require("../../../texts");
+const schema_1 = require("./schema");
+const schemaUtils_1 = require("../schemaUtils");
+const detect_1 = require("./detect");
+const render_1 = require("../render");
+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);
+    if (!action) {
+        if (options.format === 'json') {
+            output_1.default.json(null);
+            output_1.default.exitNormal();
+            return;
+        }
+        output_1.default.error((0, texts_1.ERR_ACTION_NOT_FOUND)(type));
+        const suggestions = (0, schema_1.suggestActions)(actions, 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(', ')));
+        }
+        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);
+                output_1.default.muted((0, texts_1.TXT_ACTION_SUGGESTED_FROM_REPO)(detected.map((a) => `${a.type} (${a.name})`).join(', ')));
+            }
+        }
+        output_1.default.muted(texts_1.TXT_ACTION_USE_LIST);
+        output_1.default.exitNormal();
+        return;
+    }
+    const { common, specific } = (0, schema_1.splitProperties)(action);
+    if (options.format === 'json') {
+        output_1.default.json({
+            type: action.type,
+            slug: action.slug,
+            name: action.name,
+            description: action.description,
+            required: action.required,
+            fields: {
+                specific: (0, render_1.propertiesJson)(specific, action.required),
+                common: (0, render_1.propertiesJson)(common, action.required),
+            },
+            examples: action.examples,
+        });
+        output_1.default.exitNormal();
+        return;
+    }
+    output_1.default.blue(action.name, false);
+    output_1.default.gray(` · ${action.type}`);
+    output_1.default.gray(action.description);
+    output_1.default.normal('');
+    if (Object.keys(specific).length > 0) {
+        output_1.default.blue('Type-specific fields');
+        (0, render_1.outputProperties)(specific, action.required);
+        output_1.default.normal('');
+    }
+    if (Object.keys(common).length > 0) {
+        output_1.default.blue('Common fields');
+        (0, render_1.outputProperties)(common, action.required);
+    }
+    if (action.examples.length > 0) {
+        output_1.default.normal('');
+        (0, render_1.outputExamples)(action.examples);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandYamlActionsInfo;

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

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../../utils");
+const output_1 = __importDefault(require("../../../output"));
+const texts_1 = require("../../../texts");
+const schema_1 = require("./schema");
+const schemaUtils_1 = require("../schemaUtils");
+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;
+        data.push([action.type, action.name, desc]);
+    }
+    return data;
+}
+function actionJson(actions, detectedTypes) {
+    return actions.map((action) => ({
+        type: action.type,
+        slug: action.slug,
+        name: action.name,
+        description: action.description,
+        suggested: detectedTypes.has(action.type),
+    }));
+}
+const commandYamlActionsList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_YAML_ACTIONS_LIST);
+commandYamlActionsList.alias('ls');
+commandYamlActionsList.option('-s, --search <query>', texts_1.OPTION_ACTION_SEARCH);
+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 detectedTypes = (0, detect_1.detectActions)(process.cwd());
+    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;
+        });
+        if (results.length === 0) {
+            if (options.format === 'json') {
+                output_1.default.json([]);
+                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('');
+                output_1.default.blue('Suggested based on your repo');
+                output_1.default.table(actionTable(detected));
+            }
+            output_1.default.muted(texts_1.TXT_ACTION_USE_LIST);
+            output_1.default.exitNormal();
+            return;
+        }
+        if (options.format === 'json') {
+            output_1.default.json(actionJson(results, detectedTypes));
+        }
+        else {
+            output_1.default.table(actionTable(results));
+        }
+        output_1.default.exitNormal();
+        return;
+    }
+    const byType = (a, b) => a.type.localeCompare(b.type);
+    if (options.format === 'json') {
+        output_1.default.json(actionJson([...actions].sort(byType), detectedTypes));
+        output_1.default.exitNormal();
+        return;
+    }
+    if (detectedTypes.size > 0) {
+        const detected = actions.filter((a) => detectedTypes.has(a.type)).sort(byType);
+        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.exitNormal();
+});
+exports.default = commandYamlActionsList;

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

@@ -0,0 +1,104 @@
+"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;
+const schemaUtils_1 = require("../schemaUtils");
+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() {
+    if (memCached)
+        return memCached;
+    const raw = (0, schemaUtils_1.loadRawSchema)();
+    memCached = parseSchema(raw);
+    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;
+}
+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;
+    }
+    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;
+}
+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);
+}

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

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const list_1 = __importDefault(require("./actions/list"));
+const info_1 = __importDefault(require("./actions/info"));
+const commandYamlActions = (0, utils_1.newCommand)('actions', texts_1.DESC_COMMAND_YAML_ACTIONS);
+commandYamlActions.addCommand(list_1.default);
+commandYamlActions.addCommand(info_1.default);
+commandYamlActions.addHelpText('after', `
+EXAMPLES:${texts_1.EXAMPLE_YAML_ACTIONS_LIST}
+${texts_1.EXAMPLE_YAML_ACTIONS_INFO}`);
+exports.default = commandYamlActions;

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

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCache = getCache;
+exports.setCache = setCache;
+exports.fingerprintFiles = fingerprintFiles;
+exports.pruneCache = pruneCache;
+const fs_1 = require("fs");
+const crypto_1 = require("crypto");
+const path_1 = __importDefault(require("path"));
+const diskCache_1 = require("../../diskCache");
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000; // 24h
+const MAX_ENTRIES = 100;
+function cacheFilePath(key) {
+    return path_1.default.join((0, diskCache_1.cacheRoot)(), `${(0, diskCache_1.hashKey)(key)}.json`);
+}
+function readEntry(key) {
+    try {
+        return JSON.parse((0, diskCache_1.readCached)(cacheFilePath(key)) ?? '');
+    }
+    catch {
+        return null;
+    }
+}
+function writeEntry(key, entry) {
+    (0, diskCache_1.writeCache)(cacheFilePath(key), JSON.stringify(entry));
+}
+function removeEntry(filePath) {
+    try {
+        (0, fs_1.unlinkSync)(filePath);
+    }
+    catch {
+        // ignore
+    }
+}
+function getCache(key, fingerprint) {
+    const entry = readEntry(key);
+    if (!entry)
+        return null;
+    if (entry.fingerprint !== fingerprint)
+        return null;
+    if (Date.now() - entry.createdAt > entry.ttl)
+        return null;
+    return entry.data;
+}
+function setCache(key, fingerprint, data, ttl = DEFAULT_TTL_MS) {
+    writeEntry(key, { data, fingerprint, createdAt: Date.now(), ttl });
+}
+function fingerprintFiles(dir, filenames) {
+    const hash = (0, crypto_1.createHash)('sha256');
+    hash.update(dir);
+    for (const name of filenames) {
+        const filePath = path_1.default.join(dir, name);
+        try {
+            const stat = (0, fs_1.statSync)(filePath);
+            hash.update(`${name}:${stat.mtimeMs}:${stat.size}`);
+        }
+        catch {
+            hash.update(`${name}:0`);
+        }
+    }
+    return hash.digest('hex');
+}
+function pruneCache(maxAge = 7 * 24 * 60 * 60 * 1000) {
+    (0, diskCache_1.sweepStaleCache)();
+    const dir = (0, diskCache_1.cacheRoot)();
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true })
+            .filter((e) => e.isFile() && e.name.endsWith('.json'))
+            .map((e) => e.name);
+    }
+    catch {
+        return;
+    }
+    const now = Date.now();
+    const aged = [];
+    for (const file of entries) {
+        const filePath = path_1.default.join(dir, file);
+        let entry = null;
+        try {
+            entry = JSON.parse((0, fs_1.readFileSync)(filePath, 'utf8'));
+        }
+        catch {
+            // ignore
+        }
+        // Without the createdAt check the sort below compares against NaN.
+        if (!entry || !Number.isFinite(entry.createdAt)) {
+            removeEntry(filePath);
+        }
+        else if (now - entry.createdAt > maxAge) {
+            removeEntry(filePath);
+        }
+        else {
+            aged.push({ file: filePath, createdAt: entry.createdAt });
+        }
+    }
+    if (aged.length > MAX_ENTRIES) {
+        aged.sort((a, b) => a.createdAt - b.createdAt);
+        for (let i = 0; i < aged.length - MAX_ENTRIES; i++) {
+            removeEntry(aged[i].file);
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+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();
+    if (options.format === 'json') {
+        output_1.default.json({
+            properties: (0, render_1.propertiesJson)(root.properties, root.required),
+            required: root.required,
+            examples: root.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) {
+            output_1.default.normal('');
+            (0, render_1.outputExamples)(root.examples);
+        }
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandYamlPipeline;

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

@@ -0,0 +1,111 @@
+"use strict";
+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.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 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}`);
+    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;
+    }
+    return out;
+}
+function outputProperties(properties, required) {
+    const keys = sortedKeys(properties, required);
+    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;
+        data.push([
+            key,
+            formatType(prop),
+            required.includes(key) ? 'yes' : '',
+            truncDesc,
+        ]);
+    }
+    output_1.default.table(data);
+}
+function formatExampleYaml(value) {
+    try {
+        const YAML = require('yaml');
+        const parsed = YAML.parse(value);
+        if (parsed !== null && typeof parsed === 'object') {
+            return YAML.stringify(parsed, { indent: 2 }).trimEnd();
+        }
+    }
+    catch {
+        // keep raw value on parse errors
+    }
+    return value.trimEnd();
+}
+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.gray(formatExampleYaml(ex.value));
+    }
+}