@bussolabs/closeyourit-cli 0.17.0 → 0.18.0

package/dist/lib/opencli.js

@@ -0,0 +1,149 @@
+"use strict";
+// Genera un documento OpenCLI (https://opencli.org) a partire dal manifest oclif.
+//
+// Perché: `opencli.json` scritto a mano driftava — dichiarava una versione e un elenco di comandi
+// fermi a mesi prima. Qui la fonte è il manifest oclif, che è sempre allineato ai comandi reali,
+// così il file non può più restare indietro. La parte di I/O (leggere il manifest, scrivere il
+// file) vive in `scripts/generate-opencli.mjs`; qui c'è solo la trasformazione pura, testabile.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOpenCliDocument = buildOpenCliDocument;
+// Versione della specifica OpenCLI a cui il documento si conforma.
+const OPENCLI_VERSION = '0.1';
+const SCHEMA_URL = 'https://opencli.org/draft.json';
+// oclif separa i segmenti dell'id con ':' nel manifest (indipendentemente dal topicSeparator).
+const ID_SEPARATOR = ':';
+// Opzioni globali: iniettate da oclif su ogni comando, quindi dichiarate una volta sola sul
+// comando radice come `recursive`. Sono invarianti strutturali del runtime, non comandi che
+// driftano, perciò vivono qui come costante e non nel manifest.
+const GLOBAL_OPTIONS = [
+    { name: '--help', aliases: ['-h'], description: 'Show help.', recursive: true },
+    { name: '--version', aliases: ['-V'], description: 'Show CLI version.' },
+    { name: '--json', description: 'Format output as json.', recursive: true },
+];
+// Codici di uscita del CLI: convenzione stabile, condivisa da tutti i comandi.
+const EXIT_CODES = [
+    { code: 0, description: 'Success' },
+    { code: 1, description: 'Runtime or API error' },
+    { code: 2, description: 'Invalid usage (bad flags/arguments)' },
+];
+const upper = (name) => name.toUpperCase();
+const mapArgument = (arg) => {
+    const out = { name: upper(arg.name) };
+    if (arg.required)
+        out.required = true;
+    if (arg.description)
+        out.description = arg.description;
+    if (arg.options && arg.options.length > 0)
+        out.acceptedValues = arg.options;
+    if (arg.hidden)
+        out.hidden = true;
+    return out;
+};
+const mapFlag = (flag) => {
+    const out = { name: `--${flag.name}` };
+    if (flag.char)
+        out.aliases = [`-${flag.char}`];
+    if (flag.description)
+        out.description = flag.description;
+    if (flag.required)
+        out.required = true;
+    if (flag.hidden)
+        out.hidden = true;
+    if (flag.type === 'option') {
+        const argument = { name: upper(flag.name), required: true };
+        if (flag.options && flag.options.length > 0)
+            argument.acceptedValues = flag.options;
+        out.arguments = [argument];
+    }
+    return out;
+};
+const substituteBin = (text, bin) => text.replaceAll('<%= config.bin %>', bin);
+const mapExamples = (examples, bin) => {
+    if (!examples || examples.length === 0)
+        return undefined;
+    return examples.map((ex) => substituteBin(typeof ex === 'string' ? ex : ex.command, bin));
+};
+// Applica al nodo-comando i dati del suo comando oclif. Il flag globale --json (helpGroup GLOBAL)
+// non viene ripetuto: è già dichiarato ricorsivo sul comando radice.
+const applyCommand = (node, cmd, bin) => {
+    node.description = cmd.summary ?? cmd.description;
+    if (cmd.hidden)
+        node.hidden = true;
+    if (cmd.aliases && cmd.aliases.length > 0)
+        node.aliases = cmd.aliases;
+    const flags = Object.values(cmd.flags ?? {}).filter((f) => f.helpGroup !== 'GLOBAL');
+    if (flags.length > 0)
+        node.options = flags.map((f) => mapFlag(f));
+    const args = Object.values(cmd.args ?? {});
+    if (args.length > 0)
+        node.arguments = args.map((a) => mapArgument(a));
+    const examples = mapExamples(cmd.examples, bin);
+    if (examples)
+        node.examples = examples;
+};
+const buildTree = (manifest) => {
+    const root = { name: '', path: [], children: new Map() };
+    for (const id of Object.keys(manifest.commands)) {
+        const segments = id.split(ID_SEPARATOR);
+        let node = root;
+        const path = [];
+        for (const segment of segments) {
+            path.push(segment);
+            let child = node.children.get(segment);
+            if (!child) {
+                child = { name: segment, path: [...path], children: new Map() };
+                node.children.set(segment, child);
+            }
+            node = child;
+        }
+        node.command = manifest.commands[id];
+    }
+    return root;
+};
+const toOpenCliCommand = (node, bin, topics) => {
+    const out = { name: node.name };
+    if (node.command) {
+        applyCommand(out, node.command, bin);
+    }
+    else {
+        // Topic contenitore: nessun comando proprio, la descrizione arriva da package.json (se c'è).
+        const topic = topics[node.path.join(ID_SEPARATOR)];
+        if (topic?.description)
+            out.description = topic.description;
+    }
+    if (node.children.size > 0) {
+        out.commands = [...node.children.values()]
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((child) => toOpenCliCommand(child, bin, topics));
+    }
+    return out;
+};
+/** Costruisce il documento OpenCLI completo dal manifest oclif e dai metadati di package.json. */
+function buildOpenCliDocument(input) {
+    const { manifest, bin, topics = {} } = input;
+    const info = { title: bin, version: manifest.version };
+    if (input.summary)
+        info.summary = input.summary;
+    if (input.description)
+        info.description = input.description;
+    if (input.license && (input.license.name || input.license.identifier || input.license.url)) {
+        info.license = input.license;
+    }
+    const tree = buildTree(manifest);
+    const command = {
+        name: bin,
+        ...(input.description ? { description: input.description } : {}),
+        options: GLOBAL_OPTIONS,
+        exitCodes: EXIT_CODES,
+        commands: [...tree.children.values()]
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((child) => toOpenCliCommand(child, bin, topics)),
+    };
+    return {
+        $schema: SCHEMA_URL,
+        opencli: OPENCLI_VERSION,
+        info,
+        conventions: { groupOptions: true, optionSeparator: ' ' },
+        command,
+    };
+}

package/dist/lib/output.js

@@ -142,6 +142,16 @@ const STATUS_TONE = {
     active: 'ok',
     expired: 'neutral',
     revoked: 'neutral',
+    // vulnerability advisory severity (GHSA scale). `unknown` is already neutral above — which is the
+    // right reading: an advisory OSV didn't classify is not a severe advisory.
+    critical: 'down',
+    high: 'down',
+    moderate: 'warn',
+    low: 'neutral',
+    // runtime support state
+    ending_soon: 'warn',
+    eol: 'down',
+    supported: 'ok',
 };
 /**
  * Badge colour (Tailwind family name) → tone. Ticket status/priority labels are org-customisable,