@opscompass/skills 0.1.0

package/skills/opscompass-resources/scripts/map-oracle-workloads-to-platform-cpus.tool.js

@@ -0,0 +1,24 @@
+import { asConfigList, summarize } from "./map_oracle_workloads_to_platform_cpus.js";
+export const mapOracleWorkloadsToPlatformCpusTool = {
+    name: "opscompass_resources_map_oracle_workloads_to_platform_cpus",
+    label: "map Oracle workloads to platform CPUs",
+    description: "Map Oracle workloads to Nutanix or VMware VM vCPU counts.",
+    parameters: {
+        type: "object",
+        properties: {
+            payload: { type: "array", items: { type: "object", additionalProperties: true } },
+            top: { type: "integer", minimum: 1 },
+        },
+        required: ["payload"],
+        additionalProperties: false,
+    },
+    async execute(input) {
+        const value = input;
+        if (!Array.isArray(value?.payload))
+            throw new Error("expected a JSON object or array of objects");
+        const top = value.top ?? 50;
+        if (!Number.isInteger(top) || top <= 0)
+            throw new Error("--top must be greater than 0.");
+        return { content: [{ type: "text", text: summarize(asConfigList(value.payload), top) }] };
+    },
+};

package/skills/opscompass-resources/scripts/map_oracle_workloads_to_platform_cpus.js

@@ -0,0 +1,273 @@
+import { readFileSync } from "node:fs";
+import { isMainModule } from "../.opscompass-runtime/tools/cli-entrypoint.js";
+function parseArgs(argv) {
+    const args = { input: null, top: 50 };
+    for (let i = 0; i < argv.length; i += 1) {
+        if (argv[i] === "--input") {
+            if (++i >= argv.length)
+                throw new Error("argument --input: expected one argument");
+            args.input = argv[i];
+        }
+        else if (argv[i] === "--top") {
+            if (++i >= argv.length)
+                throw new Error("argument --top: expected one argument");
+            args.top = Number(argv[i]);
+            if (!Number.isInteger(args.top))
+                throw new Error(`argument --top: invalid int value: '${argv[i]}'`);
+        }
+        else if (argv[i] === "--help" || argv[i] === "-h") {
+            console.log("Map Oracle workloads to Nutanix/VMware VM vCPU counts.");
+            process.exit(0);
+        }
+        else
+            throw new Error(`unrecognized arguments: ${argv[i]}`);
+    }
+    return args;
+}
+async function loadPayload(filePath) {
+    if (filePath)
+        return JSON.parse(readFileSync(filePath, "utf8"));
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(chunk);
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+export function asConfigList(payload) {
+    if (payload !== null &&
+        typeof payload === "object" &&
+        !Array.isArray(payload))
+        return [payload];
+    if (Array.isArray(payload))
+        return payload.filter((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+    throw new Error("expected a JSON object or array of objects");
+}
+export function getDocument(cfg) {
+    return cfg.document !== null &&
+        typeof cfg.document === "object" &&
+        !Array.isArray(cfg.document)
+        ? cfg.document
+        : {};
+}
+export function cfgType(cfg) {
+    return String(cfg.type || cfg._list_type || "").trim();
+}
+export function cfgName(cfg) {
+    return String(cfg.name || cfg._list_name || "").trim();
+}
+export function scalarInt(value) {
+    if (typeof value === "boolean" || value === null || value === undefined)
+        return null;
+    if (typeof value === "number" && Number.isFinite(value))
+        return Math.trunc(value);
+    if (typeof value === "string" && /^-?\d+$/.test(value.trim()))
+        return Number.parseInt(value.trim(), 10);
+    return null;
+}
+export function normalizeName(value) {
+    return String(value)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "");
+}
+export function oracleHostnameCandidates(cfg) {
+    const doc = getDocument(cfg), candidates = [];
+    for (const key of ["hostname", "hostName", "serverName"])
+        if (typeof doc[key] === "string" && doc[key].trim())
+            candidates.push(doc[key].trim());
+    const name = cfgName(cfg);
+    if (name.includes("(") && name.includes(")")) {
+        const start = name.indexOf("(") + 1, end = name.lastIndexOf(")");
+        const inner = name.slice(start, end).trim();
+        if (inner)
+            candidates.push(inner);
+    }
+    if (name)
+        candidates.push(name);
+    return [...new Set(candidates.map(normalizeName).filter(Boolean))];
+}
+export function recursiveFindFirst(obj, keys) {
+    if (obj !== null && typeof obj === "object") {
+        if (Array.isArray(obj)) {
+            for (const value of obj) {
+                const found = recursiveFindFirst(value, keys);
+                if (found !== undefined)
+                    return found;
+            }
+        }
+        else {
+            for (const [key, value] of Object.entries(obj))
+                if (keys.has(key.toLowerCase()))
+                    return value;
+            for (const value of Object.values(obj)) {
+                const found = recursiveFindFirst(value, keys);
+                if (found !== undefined)
+                    return found;
+            }
+        }
+    }
+    return undefined;
+}
+export function extractNutanixVcpu(doc) {
+    let sockets = scalarInt(doc.numSockets), cores = scalarInt(doc.numCoresPerSocket), threads = scalarInt(doc.numThreadsPerCore);
+    if (threads === null)
+        threads = 1;
+    if (sockets && cores && threads)
+        return [
+            sockets * cores * threads,
+            `numSockets=${sockets}, numCoresPerSocket=${cores}, numThreadsPerCore=${threads}`,
+        ];
+    const explicit = scalarInt(doc.numVcpus) ?? scalarInt(doc.numVcpusTotal);
+    return explicit !== null
+        ? [explicit, "explicit Nutanix VM vCPU field"]
+        : [null, "Nutanix CPU fields missing"];
+}
+export function extractVmwareVcpu(doc) {
+    for (const value of [
+        doc.numCpu,
+        doc.numCPU,
+        doc.cpuCount,
+        doc.numCpus,
+        doc.vcpuCount,
+    ]) {
+        const parsed = scalarInt(value);
+        if (parsed !== null)
+            return [parsed, "direct VMware VM CPU count field"];
+    }
+    const hardware = doc.hardware;
+    if (hardware !== null &&
+        typeof hardware === "object" &&
+        !Array.isArray(hardware)) {
+        const cpuHardware = hardware;
+        const numCpu = scalarInt(cpuHardware.numCPU) ?? scalarInt(cpuHardware.numCpu), cores = scalarInt(cpuHardware.numCoresPerSocket);
+        if (numCpu !== null)
+            return [
+                numCpu,
+                cores !== null
+                    ? `hardware.numCPU=${numCpu}, hardware.numCoresPerSocket=${cores}`
+                    : `hardware.numCPU=${numCpu}`,
+            ];
+    }
+    const numCpu = scalarInt(recursiveFindFirst(doc, new Set(["numcpu", "numcpus", "cpucount", "vcpucount"]))), cores = scalarInt(recursiveFindFirst(doc, new Set(["numcorespersocket"])));
+    if (numCpu !== null)
+        return [
+            numCpu,
+            cores !== null
+                ? `nested numCPU=${numCpu}, numCoresPerSocket=${cores}`
+                : "nested VMware VM CPU count field",
+        ];
+    return [null, "VMware CPU fields missing"];
+}
+export function vmIdentityCandidates(cfg) {
+    const doc = getDocument(cfg), candidates = [doc.name, cfgName(cfg), doc.guestHostname, doc.hostName]
+        .filter((value) => typeof value === "string" && Boolean(value.trim()))
+        .map((value) => normalizeName(value.trim()))
+        .filter(Boolean);
+    return [...new Set(candidates)];
+}
+export function extractVmCpu(cfg) {
+    const type = cfgType(cfg);
+    if (type === "Nutanix/Vm")
+        return extractNutanixVcpu(getDocument(cfg));
+    if (type === "vcenter/virtualMachine")
+        return extractVmwareVcpu(getDocument(cfg));
+    return [null, "unsupported VM type"];
+}
+export function platformLabel(cfg) {
+    const type = cfgType(cfg);
+    return type === "Nutanix/Vm"
+        ? "Nutanix"
+        : type === "vcenter/virtualMachine"
+            ? "VMware"
+            : type || "unknown";
+}
+export function summarize(configs, topN) {
+    const oracle = configs.filter((cfg) => cfgType(cfg) === "databases/oracle"), vms = configs.filter((cfg) => ["Nutanix/Vm", "vcenter/virtualMachine"].includes(cfgType(cfg)));
+    if (!oracle.length || !vms.length)
+        return "";
+    const index = new Map();
+    for (const vm of vms)
+        for (const candidate of vmIdentityCandidates(vm)) {
+            if (!index.has(candidate))
+                index.set(candidate, []);
+            index.get(candidate).push(vm);
+        }
+    const matched = [], unmatched = [];
+    for (const cfg of oracle) {
+        const doc = getDocument(cfg), name = cfgName(cfg) || String(doc.name || "(unnamed oracle db)"), host = String(doc.hostname || doc.hostName || "").trim();
+        let vm = null;
+        for (const candidate of oracleHostnameCandidates(cfg))
+            if (index.get(candidate)?.length) {
+                vm = index.get(candidate)[0];
+                break;
+            }
+        if (!vm) {
+            unmatched.push({
+                oracleName: name,
+                oracleHost: host || "(unknown host)",
+                reason: "no matching Nutanix/VMware VM config found",
+            });
+            continue;
+        }
+        const vmDoc = getDocument(vm), [count, basis] = extractVmCpu(vm);
+        matched.push({
+            oracleName: name,
+            oracleHost: host || "(unknown host)",
+            vmName: String(vmDoc.name || cfgName(vm) || "(unnamed vm)").trim(),
+            platform: platformLabel(vm),
+            cluster: vmDoc.cluster && typeof vmDoc.cluster === "object"
+                ? String(vmDoc.cluster.name || "").trim()
+                : "",
+            guestHostname: String(vmDoc.guestHostname || "").trim(),
+            vcpuCount: count === null ? "?" : String(count),
+            cpuBasis: basis,
+        });
+    }
+    const lines = [
+        "Oracle workload to platform vCPU summary",
+        `Oracle workload configurations collected: ${oracle.length}`,
+        `Platform VM configurations collected: ${vms.length}`,
+        `Oracle workloads matched to VMs: ${matched.length}`,
+        `Oracle workloads without VM match: ${unmatched.length}`,
+        "",
+        `Top ${topN} Oracle workload mappings:`,
+    ];
+    if (matched.length)
+        for (const item of matched.slice(0, topN)) {
+            const context = [`platform=${item.platform}`];
+            if (item.cluster)
+                context.push(`cluster=${item.cluster}`);
+            if (item.guestHostname &&
+                normalizeName(item.guestHostname) !== normalizeName(item.vmName))
+                context.push(`guest=${item.guestHostname}`);
+            context.push(`cpu_basis=${item.cpuBasis}`);
+            lines.push(`- ${item.oracleName} -> ${item.vmName} -> provisioned_vcpu=${item.vcpuCount} (${context.join(", ")})`);
+        }
+    else
+        lines.push("- none");
+    if (unmatched.length) {
+        lines.push("", `Top ${topN} Oracle workloads without VM match:`);
+        for (const item of unmatched.slice(0, topN))
+            lines.push(`- ${item.oracleName} (host=${item.oracleHost}): ${item.reason}`);
+    }
+    return lines.join("\n");
+}
+export async function main(argv = process.argv.slice(2)) {
+    try {
+        const args = parseArgs(argv);
+        if (args.top <= 0) {
+            console.error("Error: --top must be greater than 0.");
+            return 2;
+        }
+        const configs = asConfigList(await loadPayload(args.input));
+        console.log(summarize(configs, args.top));
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof SyntaxError
+            ? `Error: invalid JSON: ${error.message}`
+            : `Error: ${error instanceof Error ? error.message : String(error)}`);
+        return 2;
+    }
+}
+if (isMainModule(import.meta.url)) {
+    process.exitCode = await main();
+}

package/skills/opscompass-resources/scripts/opscompass-defaults.tool.js

@@ -0,0 +1,80 @@
+import { runCli } from "../.opscompass-runtime/tools/opsc-cli.js";
+import { buildSetDefaultsCommand, buildSetupCommand, commandText, getDefaultCompany, getDefaultsPath, loadDefaults, } from "../.opscompass-runtime/tools/index.js";
+export const opscompassDefaultsTool = {
+    name: "opscompass_resources_defaults",
+    label: "inspect Opscompass defaults",
+    description: "List or build safe Opscompass defaults commands.",
+    parameters: {
+        type: "object",
+        properties: {
+            command: { type: "string", enum: ["list", "set", "setup", "ignore"] },
+            company: { type: "string" },
+            account: { type: "string" },
+            monitoringConfigurationId: { type: "string" },
+            maskValues: { type: "array", items: { type: "string" } },
+            dryRun: { type: "boolean" },
+            cli: { type: "boolean" },
+            nonInteractive: { type: "boolean" },
+        },
+        required: ["command"],
+        additionalProperties: false,
+    },
+    async execute(input, context) {
+        const value = (input ?? {});
+        const command = value.command;
+        if (!command || !["list", "set", "setup", "ignore"].includes(command))
+            throw new Error(`invalid command: ${command}`);
+        if (command === "list") {
+            if (value.cli)
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: await runCli(context, ["defaults", "list-defaults"]),
+                        },
+                    ],
+                };
+            const defaultsPath = getDefaultsPath(context);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            company: getDefaultCompany(defaultsPath),
+                            defaults: loadDefaults(defaultsPath),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        if (command === "set") {
+            const args = buildSetDefaultsCommand(value, context);
+            if (!value.dryRun)
+                await runCli(context, args.slice(1));
+            return { content: [{ type: "text", text: commandText(args) }] };
+        }
+        if (command === "setup") {
+            const args = buildSetupCommand(value, context);
+            if (!value.dryRun)
+                await runCli(context, args.slice(1));
+            return { content: [{ type: "text", text: commandText(args) }] };
+        }
+        const company = value.company ?? "<company>";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: commandText([
+                        context.cliCommand,
+                        "resources",
+                        "list",
+                        "--company",
+                        company,
+                        "--resource-types",
+                        "databases/oracle",
+                    ]),
+                },
+            ],
+        };
+    },
+};

package/skills/opscompass-resources/scripts/opscompass-resources.tool.js

@@ -0,0 +1,51 @@
+import { runCli } from "../.opscompass-runtime/tools/opsc-cli.js";
+import { commandText } from "./build_resources_command.js";
+const ACTIONS = [
+    "resources list",
+    "resources get-latest-configuration",
+    "resources get-compliance",
+];
+export const opscompassResourcesTool = {
+    name: "opscompass_resources",
+    label: "opscompass resources",
+    description: "Run approved read-only Opscompass resource commands.",
+    promptSnippet: "Run approved Opscompass resource queries",
+    promptGuidelines: [
+        "Use numeric --id values from resources list for follow-up actions.",
+        "Do not use --resource-id or --resource-ids.",
+        "When reporting an executed command, copy the complete command at the start of the tool result, including its CLI identity and all flags. Do not reconstruct it from the generic tool label or production examples.",
+    ],
+    parameters: {
+        type: "object",
+        properties: {
+            action: { type: "string", enum: [...ACTIONS] },
+            args: { type: "array", items: { type: "string" } },
+        },
+        required: ["action", "args"],
+        additionalProperties: false,
+    },
+    async execute(input, context) {
+        if (!input || typeof input !== "object")
+            throw new Error("Opscompass action input must be an object.");
+        const value = input;
+        if (typeof value.action !== "string" ||
+            !ACTIONS.includes(value.action)) {
+            throw new Error("Only approved Opscompass resources actions are allowed.");
+        }
+        if (!Array.isArray(value.args) ||
+            value.args.length > 40 ||
+            value.args.some((arg) => typeof arg !== "string" || arg.length > 1_000 || arg.includes("\0"))) {
+            throw new Error("Opscompass action arguments are invalid.");
+        }
+        const args = value.args;
+        if (args.some((arg) => arg === "--resource-id" || arg === "--resource-ids")) {
+            throw new Error("Use numeric --id values from resources list; resource-id flags are not allowed.");
+        }
+        const command = [context.cliCommand, ...value.action.split(" "), ...args];
+        const output = await runCli(context, command.slice(1));
+        // WHY: Keep the executed command and output together, matching the builder's receipt.
+        return {
+            content: [{ type: "text", text: `${commandText(command)}\n\n${output}` }],
+        };
+    },
+};

package/skills/opscompass-resources/scripts/summarize-latest-configuration.tool.js

@@ -0,0 +1,24 @@
+import { asConfigList, summarizeMany } from "./summarize_latest_configuration.js";
+export const summarizeLatestConfigurationTool = {
+    name: "opscompass_resources_summarize_latest_configuration",
+    label: "summarize latest configuration",
+    description: "Summarize one or more latest-configuration JSON payloads.",
+    parameters: {
+        type: "object",
+        properties: {
+            payload: { type: "array", items: { type: "object", additionalProperties: true } },
+            top: { type: "integer", minimum: 1 },
+        },
+        required: ["payload"],
+        additionalProperties: false,
+    },
+    async execute(input) {
+        const value = input;
+        if (!Array.isArray(value?.payload))
+            throw new Error("expected a JSON object or array of objects");
+        const top = value.top ?? 5;
+        if (!Number.isInteger(top) || top <= 0)
+            throw new Error("--top must be greater than 0.");
+        return { content: [{ type: "text", text: summarizeMany(asConfigList(value.payload), top) }] };
+    },
+};

package/skills/opscompass-resources/scripts/summarize-resources-list.tool.js

@@ -0,0 +1,24 @@
+import { summarize } from "./summarize_resources_list.js";
+export const summarizeResourcesListTool = {
+    name: "opscompass_resources_summarize_resources_list",
+    label: "summarize resources list",
+    description: "Summarize a resources list JSON payload.",
+    parameters: {
+        type: "object",
+        properties: {
+            payload: { type: "array", items: { type: "object", additionalProperties: true } },
+            top: { type: "integer", minimum: 1 },
+        },
+        required: ["payload"],
+        additionalProperties: false,
+    },
+    async execute(input) {
+        const value = input;
+        if (!Array.isArray(value?.payload))
+            throw new Error("expected top-level JSON array.");
+        const top = value.top ?? 10;
+        if (!Number.isInteger(top) || top <= 0)
+            throw new Error("--top must be greater than 0.");
+        return { content: [{ type: "text", text: summarize(value.payload, top) }] };
+    },
+};