bdy 1.25.2-stage → 1.25.4-dev

package/distTs/src/discovery.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverCommands = exports.describeCommand = void 0;
+const cliCommand_1 = __importDefault(require("./cliCommand"));
+const texts_1 = require("./texts");
+const sortedChildren = (command) => command
+    .createHelp()
+    .visibleCommands(command)
+    // Commander may append a synthetic help command. Only expose registered commands.
+    .filter((child) => command.commands.includes(child))
+    .sort((a, b) => (a.name() < b.name() ? -1 : a.name() > b.name() ? 1 : 0));
+const commandPath = (command) => command.parent
+    ? `${commandPath(command.parent)} ${command.name()}`
+    : command.name() || 'bdy';
+const optionInfo = (option) => {
+    const value = option.flags.match(/[<[]([^>\]]+)[>\]]/)?.[1] ?? null;
+    // These are static documentation, never resolved values from opts(), env or config.
+    const env = option.envVar ??
+        option.description.match(/Can be set via variable:\s*([A-Z][A-Z0-9_]*)/)?.[1] ??
+        null;
+    const documentedDefault = option.description.match(/Default:\s*(.+)$/)?.[1] ?? null;
+    const choices = option.argChoices ??
+        (value &&
+            /^[A-Za-z][A-Za-z0-9_-]*(?:\|[A-Za-z][A-Za-z0-9_-]*)+$/.test(value)
+            ? value.split('|')
+            : null);
+    return {
+        flags: option.flags,
+        short: option.short ?? null,
+        long: option.long ?? null,
+        description: option.description,
+        required: option.mandatory,
+        value: value
+            ? {
+                name: value,
+                required: option.required,
+                variadic: !!option.variadic,
+            }
+            : null,
+        negated: option.negate,
+        choices,
+        default: option.defaultValue ?? null,
+        documented_default: documentedDefault,
+        env,
+    };
+};
+const describeCommand = (command) => ({
+    command: commandPath(command),
+    aliases: command.aliases(),
+    description: command.description(),
+    usage: `${commandPath(command)} ${command.usage()}`.trim(),
+    arguments: command.registeredArguments.map((argument) => ({
+        name: argument.name(),
+        description: argument.description,
+        required: argument.required,
+        variadic: argument.variadic,
+        choices: argument.argChoices ?? null,
+        default: argument.defaultValue ?? null,
+    })),
+    options: command
+        .createHelp()
+        .visibleOptions(command)
+        .filter((option) => option.long !== '--help')
+        .map(optionInfo),
+    required_scopes: command instanceof cliCommand_1.default ? command.requiredScopes : null,
+    examples: command instanceof cliCommand_1.default ? command.examples : [],
+});
+exports.describeCommand = describeCommand;
+const describeTree = (command) => ({
+    ...(0, exports.describeCommand)(command),
+    subcommands: sortedChildren(command).map(describeTree),
+});
+const summarizeTree = (command) => [
+    {
+        command: commandPath(command),
+        description: command.description(),
+    },
+    ...sortedChildren(command).flatMap(summarizeTree),
+];
+const discoverCommands = (program, path, version, full = false) => {
+    let selected = program;
+    const selectedPath = [];
+    for (const part of path) {
+        const child = sortedChildren(selected).find((command) => command.name() === part || command.aliases().includes(part));
+        if (!child)
+            return {
+                error: {
+                    code: 'unknown_command',
+                    message: (0, texts_1.ERR_DISCOVER_UNKNOWN_COMMAND)(part, commandPath(selected)),
+                    hint: (0, texts_1.TXT_DISCOVER_COMMAND_HINT)(selectedPath),
+                },
+            };
+        selected = child;
+        selectedPath.push(child.name());
+    }
+    const commands = selected === program ? sortedChildren(program) : [selected];
+    const includeDetails = full || (selected !== program && sortedChildren(selected).length === 0);
+    return {
+        schema_version: 1,
+        cli_version: version,
+        // Root flags must precede the subcommand; keep them separate from local options.
+        ...(includeDetails
+            ? {
+                global_options: program
+                    .createHelp()
+                    .visibleOptions(program)
+                    .map(optionInfo),
+            }
+            : {}),
+        commands: includeDetails
+            ? commands.map(describeTree)
+            : commands.flatMap(summarizeTree),
+        tips: texts_1.DISCOVERY_TIPS,
+    };
+};
+exports.discoverCommands = discoverCommands;

package/distTs/src/openapi.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apiEndpoints = apiEndpoints;
+exports.apiSpecification = apiSpecification;
 const docs_schema_1 = require("@buddy-works/docs-schema");
 const texts_1 = require("./texts");
 const utils_1 = require("./utils");
 const diskCache_1 = require("./diskCache");
 let held = null;
+let specification = null;
 async function apiEndpoints(baseUrl) {
     if (held)
         return held;
@@ -18,10 +20,15 @@ async function apiEndpoints(baseUrl) {
     if (!raw)
         throw new Error(texts_1.ERR_SCHEMA_FETCH_FAILED);
     try {
-        held = docs_schema_1.BuddySchema.from({ api: JSON.parse(raw) }).api;
+        specification = JSON.parse(raw);
+        held = docs_schema_1.BuddySchema.from({ api: specification }).api;
     }
     catch {
         throw new Error(texts_1.ERR_SCHEMA_FETCH_FAILED);
     }
     return held;
 }
+async function apiSpecification(baseUrl) {
+    await apiEndpoints(baseUrl);
+    return specification;
+}

package/distTs/src/output.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const texts_1 = require("./texts");
 const utils_1 = require("./utils");
 const chalk_1 = __importDefault(require("chalk"));
+const node_readline_1 = require("node:readline");
 let _terminal = null;
 function getTerminal() {
     if (!_terminal) {
@@ -134,6 +135,15 @@ class Output {
             msg += '\n';
         getTerminal()(msg);
     }
+    static progress(quiet, output = this.normal.bind(this)) {
+        return (txt, newLine = true, replacePrevious = false) => {
+            if (quiet)
+                return;
+            if (replacePrevious)
+                this.clearPreviousLine();
+            output(txt, newLine);
+        };
+    }
     // Payload output (command results, logs, JSON): bypasses terminal-kit,
     // whose printf-style formatting and ^-markup corrupt data containing
     // % or ^ sequences. newLine=false emits a mid-stream chunk, keeping
@@ -652,6 +662,35 @@ class Output {
     static json(json) {
         this.data(JSON.stringify(json));
     }
+    static async streamCommandLogs(body, jsonl) {
+        // readline preserves UTF-8 and records split across transport chunks.
+        const lines = (0, node_readline_1.createInterface)({ input: body, crlfDelay: Infinity });
+        for await (const line of lines) {
+            if (!line.trim())
+                continue;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (typeof record?.data !== 'string')
+                continue;
+            if (jsonl) {
+                this.json({
+                    type: 'log',
+                    ...(record.stream === 'stdout' || record.stream === 'stderr'
+                        ? { stream: record.stream }
+                        : {}),
+                    data: record.data,
+                });
+            }
+            else if (record.data) {
+                this.data(record.data);
+            }
+        }
+    }
     static exitError(err) {
         this.clearUndici();
         this.clearTerminal();