bdy 1.23.2-dev → 1.23.4-dev-target-commands

package/distTs/src/command/target/get.js

@@ -0,0 +1,62 @@
+"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 output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+const scope_1 = require("./scope");
+const commandTargetGet = (0, utils_1.newCommand)('get', texts_1.DESC_COMMAND_TARGET_GET);
+commandTargetGet.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetGet.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetGet.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetGet.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetGet.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandTargetGet.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
+commandTargetGet.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_GET}`);
+commandTargetGet.action(async (identifier, options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options);
+    const target = await client.getTarget(workspace, target_id);
+    if (options.format === 'json') {
+        output_1.default.json(target);
+    }
+    else {
+        const data = [
+            ['Field', 'Value'],
+            ['ID', target.id || '-'],
+            ['Identifier', target.identifier || '-'],
+            ['Name', target.name || '-'],
+            ['Type', target.type || '-'],
+            ['Scope', (0, scope_1.targetScopeOf)(target)],
+            ['Tags', (target.tags || []).join(', ') || '-'],
+            ['Note', target.note || '-'],
+            ['Agent note', target.agent_note || '-'],
+            ['Disabled', target.disabled ? 'true' : 'false'],
+        ];
+        if (target.project) {
+            data.push(['Project', target.project.name || '-']);
+        }
+        if (target.pipeline) {
+            data.push([
+                'Pipeline',
+                target.pipeline.identifier || String(target.pipeline.id) || '-',
+            ]);
+        }
+        if (target.environment) {
+            data.push([
+                'Environment',
+                target.environment.identifier || target.environment.id || '-',
+            ]);
+        }
+        if (target.html_url) {
+            data.push(['URL', target.html_url]);
+        }
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandTargetGet;

package/distTs/src/command/target/list.js

@@ -0,0 +1,48 @@
+"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 output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+const scope_1 = require("./scope");
+const commandTargetList = (0, utils_1.newCommand)('list', texts_1.DESC_COMMAND_TARGET_LIST);
+commandTargetList.alias('ls');
+commandTargetList.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetList.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetList.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetList.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetList.option('--scope <scope>', texts_1.OPT_COMMAND_TARGET_SCOPE);
+commandTargetList.option('--format <text|json>', texts_1.OPTION_FORMAT);
+commandTargetList.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_LIST}`);
+commandTargetList.action(async (options) => {
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const project = input_1.default.restApiProject(options.project, true);
+    const scope = input_1.default.targetScope(project, options.pipeline, options.environment, options.scope);
+    const client = input_1.default.restApiTokenClient();
+    const filters = await (0, scope_1.resolveTargetScope)(client, workspace, project, scope, options);
+    const result = await client.getTargets(workspace, filters);
+    const targets = result.targets || [];
+    if (options.format === 'json') {
+        output_1.default.json(targets);
+    }
+    else {
+        if (targets.length === 0) {
+            output_1.default.exitNormal(texts_1.TXT_TARGET_NOT_FOUND);
+        }
+        const data = [['NAME', 'IDENTIFIER', 'TYPE', 'SCOPE']];
+        for (const target of targets) {
+            data.push([
+                target.name || '-',
+                target.identifier || '-',
+                target.type || '-',
+                (0, scope_1.targetScopeOf)(target),
+            ]);
+        }
+        output_1.default.table(data);
+    }
+    output_1.default.exitNormal();
+});
+exports.default = commandTargetList;

package/distTs/src/command/target/scope.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTargetScope = exports.targetScopeOf = exports.resolveTargetId = void 0;
+const utils_1 = require("../../utils");
+const texts_1 = require("../../texts");
+const output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+// Shared resolve preamble for commands taking a target identifier: line
+// context from flags/env -> /identifiers -> hash id, exiting on a miss.
+const resolveTargetId = async (client, workspace, identifier, options) => {
+    const project = input_1.default.restApiProject(options.project, true);
+    const line = input_1.default.targetLine(project, options.pipeline, options.environment);
+    const { target_id } = await client.getTargetByIdentifier(workspace, identifier, line);
+    if (!target_id) {
+        output_1.default.exitError(texts_1.ERR_TARGET_NOT_FOUND);
+    }
+    return target_id;
+};
+exports.resolveTargetId = resolveTargetId;
+const targetScopeOf = (target) => {
+    if (target.pipeline)
+        return utils_1.TARGET_SCOPE.PIPELINE;
+    if (target.environment)
+        return utils_1.TARGET_SCOPE.ENVIRONMENT;
+    if (target.project)
+        return utils_1.TARGET_SCOPE.PROJECT;
+    return utils_1.TARGET_SCOPE.WORKSPACE;
+};
+exports.targetScopeOf = targetScopeOf;
+// Input.targetScope guarantees project is set for the PIPELINE scope.
+// Environments exist on both workspace and project level, so for the
+// ENVIRONMENT scope project is optional and narrows the lookup when given.
+const resolveTargetScope = async (client, workspace, project, scope, options) => {
+    const params = {};
+    if (scope === utils_1.TARGET_SCOPE.PIPELINE) {
+        const { pipeline_id } = await client.getPipelineByIdentifier(workspace, project, options.pipeline);
+        if (!pipeline_id)
+            output_1.default.exitError(texts_1.ERR_PIPELINE_NOT_FOUND);
+        params.pipelineId = pipeline_id;
+    }
+    else if (scope === utils_1.TARGET_SCOPE.ENVIRONMENT) {
+        const query = {
+            environment: options.environment,
+        };
+        if (project)
+            query.project = project;
+        const { environment_id } = await client.getResourceByIdentifier(workspace, query);
+        if (!environment_id)
+            output_1.default.exitError(texts_1.ERR_TARGET_ENVIRONMENT_NOT_FOUND);
+        params.environmentId = environment_id;
+    }
+    else if (scope === utils_1.TARGET_SCOPE.PROJECT) {
+        params.project = project;
+    }
+    return params;
+};
+exports.resolveTargetScope = resolveTargetScope;

package/distTs/src/command/target/update.js

@@ -0,0 +1,31 @@
+"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 output_1 = __importDefault(require("../../output"));
+const input_1 = __importDefault(require("../../input"));
+const scope_1 = require("./scope");
+const commandTargetUpdate = (0, utils_1.newCommand)('update', texts_1.DESC_COMMAND_TARGET_UPDATE);
+commandTargetUpdate.alias('edit');
+commandTargetUpdate.option('-w, --workspace <domain>', texts_1.OPTION_REST_API_WORKSPACE);
+commandTargetUpdate.option('-p, --project <name>', texts_1.OPTION_REST_API_PROJECT);
+commandTargetUpdate.option('--pipeline <identifier>', texts_1.OPTION_TARGET_PIPELINE);
+commandTargetUpdate.option('--environment <identifier>', texts_1.OPTION_TARGET_ENVIRONMENT);
+commandTargetUpdate.option('--yaml <content|@path>', texts_1.OPTION_TARGET_YAML);
+commandTargetUpdate.argument('<identifier>', texts_1.OPTION_TARGET_IDENTIFIER);
+commandTargetUpdate.addHelpText('after', `\nEXAMPLES:${texts_1.EXAMPLE_TARGET_UPDATE}`);
+commandTargetUpdate.action(async (identifier, options) => {
+    const yaml = input_1.default.restApiYaml(options.yaml);
+    const workspace = input_1.default.restApiWorkspace(options.workspace);
+    const client = input_1.default.restApiTokenClient();
+    const target_id = await (0, scope_1.resolveTargetId)(client, workspace, identifier, options);
+    const body = {
+        yaml: Buffer.from(yaml, 'utf8').toString('base64'),
+    };
+    const result = await client.updateTargetByYaml(workspace, target_id, body);
+    output_1.default.exitSuccess((0, texts_1.TXT_TARGET_UPDATED)(result.identifier, result.html_url));
+});
+exports.default = commandTargetUpdate;

package/distTs/src/command/target.js

@@ -0,0 +1,22 @@
+"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("./target/list"));
+const get_1 = __importDefault(require("./target/get"));
+const create_1 = __importDefault(require("./target/create"));
+const update_1 = __importDefault(require("./target/update"));
+const delete_1 = __importDefault(require("./target/delete"));
+const exec_1 = __importDefault(require("./target/exec"));
+const commandTarget = (0, utils_1.newCommand)('target', texts_1.DESC_COMMAND_TARGET);
+commandTarget.alias('tg');
+commandTarget.addCommand(list_1.default);
+commandTarget.addCommand(get_1.default);
+commandTarget.addCommand(create_1.default);
+commandTarget.addCommand(update_1.default);
+commandTarget.addCommand(delete_1.default);
+commandTarget.addCommand(exec_1.default);
+exports.default = commandTarget;

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

@@ -0,0 +1,268 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectActions = detectActions;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const picomatch_1 = __importDefault(require("picomatch"));
+const utils_1 = require("../../../utils");
+const cache_1 = require("../cache");
+const DETECT_CACHE_TTL = 10 * 60 * 1000; // 10 minutes
+const DETECT_CACHE_PREFIX = 'detect:';
+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'));
+    return cachedRules;
+}
+function safeReadDir(dir) {
+    try {
+        return (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function readDirIndex(dir) {
+    const names = [];
+    const lowerNames = new Set();
+    const lowerDirs = new Set();
+    for (const entry of safeReadDir(dir)) {
+        names.push(entry.name);
+        lowerNames.add(entry.name.toLowerCase());
+        if (entry.isDirectory())
+            lowerDirs.add(entry.name.toLowerCase());
+    }
+    return { names, lowerNames, lowerDirs };
+}
+function existsCaseInsensitive(dir, relPath, mustBeDir) {
+    const segments = relPath.split('/').filter(Boolean);
+    if (segments.length === 0)
+        return false;
+    let current = dir;
+    for (let i = 0; i < segments.length; i++) {
+        const lower = segments[i].toLowerCase();
+        const found = safeReadDir(current).find((e) => e.name.toLowerCase() === lower);
+        if (!found)
+            return false;
+        if (i === segments.length - 1 && mustBeDir && !found.isDirectory())
+            return false;
+        current = path_1.default.join(current, found.name);
+    }
+    return true;
+}
+function fileMatchesAny(patterns, dir, index) {
+    for (const pattern of patterns) {
+        if (pattern.includes('*')) {
+            const isMatch = (0, picomatch_1.default)(pattern, { nocase: true, dot: true });
+            if (index.names.some((name) => isMatch(name)))
+                return true;
+        }
+        else if (pattern.includes('/')) {
+            const mustBeDir = pattern.endsWith('/');
+            const rel = mustBeDir ? pattern.slice(0, -1) : pattern;
+            if (rel.includes('/')) {
+                if (existsCaseInsensitive(dir, rel, mustBeDir))
+                    return true;
+            }
+            else if (mustBeDir) {
+                if (index.lowerDirs.has(rel.toLowerCase()))
+                    return true;
+            }
+            else if (index.lowerNames.has(rel.toLowerCase())) {
+                return true;
+            }
+        }
+        else if (index.lowerNames.has(pattern.toLowerCase())) {
+            return true;
+        }
+    }
+    return false;
+}
+function parsePackageJson(content) {
+    const pkg = JSON.parse(content);
+    return Object.keys({ ...pkg.dependencies, ...pkg.devDependencies });
+}
+function parseRequirementsTxt(content) {
+    const names = [];
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('-')) {
+            names.push(trimmed.split(/[>=<!~[;]/)[0].trim());
+        }
+    }
+    return names;
+}
+function parseComposerJson(content) {
+    const composer = JSON.parse(content);
+    return Object.keys({ ...composer.require, ...composer['require-dev'] });
+}
+function parseGoMod(content) {
+    const names = [];
+    const requireBlocks = content.match(/require\s*\(([\s\S]*?)\)/g);
+    if (requireBlocks) {
+        for (const block of requireBlocks) {
+            for (const line of block.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed && !trimmed.startsWith('//') && !trimmed.startsWith('require') && trimmed !== ')') {
+                    names.push(trimmed.split(/\s/)[0]);
+                }
+            }
+        }
+    }
+    const singleReqs = content.match(/^require\s+(\S+)/gm);
+    if (singleReqs) {
+        for (const req of singleReqs)
+            names.push(req.replace(/^require\s+/, '').trim());
+    }
+    return names;
+}
+function parseGemfile(content) {
+    const names = [];
+    for (const line of content.split('\n')) {
+        const match = line.match(/^\s*gem\s+['"]([^'"]+)['"]/);
+        if (match)
+            names.push(match[1]);
+    }
+    return names;
+}
+function parsePubspec(content) {
+    const YAML = require('yaml');
+    const pubspec = YAML.parse(content) || {};
+    return [
+        ...Object.keys(pubspec.dependencies || {}),
+        ...Object.keys(pubspec.dev_dependencies || {}),
+    ];
+}
+function parseCargoToml(content) {
+    const names = [];
+    const depSection = content.match(/\[dependencies]([\s\S]*?)(?=\n\[|$)/);
+    if (depSection) {
+        for (const line of depSection[1].split('\n')) {
+            const match = line.match(/^(\S+)\s*=/);
+            if (match)
+                names.push(match[1]);
+        }
+    }
+    return names;
+}
+function parsePomXml(content) {
+    const names = [];
+    const artifacts = content.match(/<artifactId>([^<]+)<\/artifactId>/g);
+    if (artifacts) {
+        for (const a of artifacts)
+            names.push(a.replace(/<\/?artifactId>/g, ''));
+    }
+    return names;
+}
+function parseGradle(content) {
+    const names = [];
+    const deps = content.match(/(?:implementation|api|compile|testImplementation)\s*[('"]([^'"()]+)['")\s]/g);
+    if (deps) {
+        for (const d of deps) {
+            const match = d.match(/['"]([^'"]+)['"]/);
+            if (match)
+                names.push(match[1]);
+        }
+    }
+    return names;
+}
+function parsePyproject(content) {
+    const names = [];
+    const depMatch = content.match(/dependencies\s*=\s*\[([\s\S]*?)]/);
+    if (depMatch) {
+        const items = depMatch[1].match(/["']([^"'>=<![;]+)/g);
+        if (items) {
+            for (const item of items)
+                names.push(item.replace(/^["']/, '').trim());
+        }
+    }
+    return names;
+}
+const MANIFEST_PARSERS = [
+    { file: 'package.json', parse: parsePackageJson },
+    { file: 'requirements.txt', parse: parseRequirementsTxt },
+    { file: 'composer.json', parse: parseComposerJson },
+    { file: 'go.mod', parse: parseGoMod },
+    { file: 'Gemfile', parse: parseGemfile },
+    { file: 'pubspec.yaml', parse: parsePubspec },
+    { file: 'Cargo.toml', parse: parseCargoToml },
+    { file: 'pom.xml', parse: parsePomXml },
+    { file: 'build.gradle', parse: parseGradle },
+    { file: 'build.gradle.kts', parse: parseGradle },
+    { file: 'pyproject.toml', parse: parsePyproject },
+];
+const LOCKFILES = ['package-lock.json', 'composer.lock', 'go.sum', 'Gemfile.lock', 'pubspec.lock', 'Cargo.lock'];
+const MANIFEST_FILES = [...new Set(MANIFEST_PARSERS.map((p) => p.file)), ...LOCKFILES];
+function readPackageNames(dir) {
+    const packages = new Set();
+    for (const { file, parse } of MANIFEST_PARSERS) {
+        const filePath = path_1.default.join(dir, file);
+        if (!(0, fs_1.existsSync)(filePath))
+            continue;
+        try {
+            for (const name of parse((0, fs_1.readFileSync)(filePath, 'utf8'))) {
+                if (name)
+                    packages.add(name);
+            }
+        }
+        catch {
+            // ignore malformed manifests
+        }
+    }
+    return packages;
+}
+function packageMatchesPattern(pkg, pattern) {
+    if (pattern.endsWith('/*')) {
+        const prefix = pattern.slice(0, -2);
+        return pkg.startsWith(prefix + '/');
+    }
+    return pkg === pattern;
+}
+function scanActions(dir) {
+    const rules = loadDetectRules();
+    const packages = readPackageNames(dir);
+    const detectedTypes = [];
+    const index = readDirIndex(dir);
+    for (const [type, rule] of Object.entries(rules)) {
+        let matched = false;
+        if (rule.files) {
+            matched = fileMatchesAny(rule.files, dir, index);
+        }
+        if (!matched && rule.packages) {
+            for (const pkgPattern of rule.packages) {
+                for (const pkg of packages) {
+                    if (packageMatchesPattern(pkg, pkgPattern)) {
+                        matched = true;
+                        break;
+                    }
+                }
+                if (matched)
+                    break;
+            }
+        }
+        if (matched) {
+            detectedTypes.push(type);
+        }
+    }
+    return detectedTypes;
+}
+let pruneScheduled = false;
+function detectActions(dir) {
+    const cacheKey = DETECT_CACHE_PREFIX + dir;
+    const fingerprint = (0, cache_1.fingerprintFiles)(dir, MANIFEST_FILES);
+    const cached = (0, cache_1.getCache)(cacheKey, fingerprint);
+    if (cached)
+        return new Set(cached);
+    const detected = scanActions(dir);
+    (0, cache_1.setCache)(cacheKey, fingerprint, detected, DETECT_CACHE_TTL);
+    if (!pruneScheduled) {
+        pruneScheduled = true;
+        process.nextTick(() => (0, cache_1.pruneCache)());
+    }
+    return new Set(detected);
+}

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

@@ -0,0 +1,56 @@
+"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.action(async (type) => {
+    await (0, schemaUtils_1.ensureYamlSchema)();
+    const actions = (0, schema_1.loadSchema)();
+    const action = (0, schema_1.findAction)(actions, type);
+    if (!action) {
+        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(`Suggested based on your repo: ${detected.map((a) => `${a.type} (${a.name})`).join(', ')}`);
+            }
+        }
+        output_1.default.muted(texts_1.TXT_ACTION_USE_LIST);
+        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('');
+    const { common, specific } = (0, schema_1.splitProperties)(action);
+    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,70 @@
+"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;
+}
+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.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) {
+            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;
+        }
+        output_1.default.table(actionTable(results));
+        output_1.default.exitNormal();
+        return;
+    }
+    const byType = (a, b) => a.type.localeCompare(b.type);
+    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;