@ornncompute/cli 0.1.9 → 0.2.0

package/vendor/capabilities/capability.js

@@ -0,0 +1,59 @@
+import { namesFromId } from "./names.js";
+export const DOMAINS = [
+    "identity",
+    "listings",
+    "fleet",
+    "users",
+    "reservations",
+    "bids",
+    "access",
+    "clusters",
+    "slurm",
+    "kubernetes",
+    "networks",
+    "storage",
+    "vpn",
+    "billing",
+];
+/** Fill CLI/MCP/Slack names from `id`. Slack parameters stay optional. */
+export function defineCapability(spec) {
+    const names = namesFromId(spec.id);
+    return {
+        ...spec,
+        cli: { command: names.cli },
+        mcp: { name: names.mcp },
+        slack: {
+            name: names.slack,
+            ...(spec.slack?.parameters ? { parameters: spec.slack.parameters } : {}),
+        },
+    };
+}
+export function slackStaffVisible(capability) {
+    return capability.roles.some((role) => role === "reviewer" || role === "admin");
+}
+export function visibleToClient(capability, client, role) {
+    if (!capability.roles.includes(role))
+        return false;
+    if (client === "slack") {
+        if (role === "user")
+            return false;
+        return slackStaffVisible(capability) && capability.slack != null;
+    }
+    if (client === "cli")
+        return capability.cli != null;
+    return capability.mcp != null;
+}
+export function forRole(catalog, role, client) {
+    return catalog.filter((capability) => visibleToClient(capability, client, role));
+}
+export function byMcpName(catalog, name) {
+    return catalog.find((capability) => capability.mcp?.name === name);
+}
+export function bySlackName(catalog, name) {
+    return catalog.find((capability) => capability.slack?.name === name);
+}
+export function byCliCommand(catalog, command) {
+    return catalog.find((capability) => capability.cli != null &&
+        capability.cli.command.length === command.length &&
+        capability.cli.command.every((part, index) => part === command[index]));
+}

package/vendor/capabilities/catalog.d.ts

@@ -0,0 +1,3 @@
+import type { Capability } from "./capability.ts";
+/** System of record for CLI, MCP, and Slack verbs. Add capabilities here. */
+export declare const catalog: Capability[];

package/vendor/capabilities/catalog.js

@@ -0,0 +1,14 @@
+import { kubernetesCapabilities, slurmCapabilities } from "./capabilities/clusters.js";
+import { fleetCapabilities } from "./capabilities/fleet.js";
+import { identityCapabilities } from "./capabilities/identity.js";
+import { listingCapabilities } from "./capabilities/listings.js";
+import { userCapabilities } from "./capabilities/users.js";
+/** System of record for CLI, MCP, and Slack verbs. Add capabilities here. */
+export const catalog = [
+    ...identityCapabilities,
+    ...listingCapabilities,
+    ...fleetCapabilities,
+    ...userCapabilities,
+    ...slurmCapabilities,
+    ...kubernetesCapabilities,
+];

package/vendor/capabilities/index.d.ts

@@ -0,0 +1,10 @@
+export { byCliCommand, byMcpName, bySlackName, defineCapability, forRole, slackStaffVisible, visibleToClient, type Capability, type CapabilityBindings, type CapabilityContext, type CapabilitySpec, type JsonSchema, type CapabilityTransport, type Domain, type HttpSpec, type Mutation, } from "./capability.ts";
+export { namesFromId } from "./names.ts";
+export { catalog } from "./catalog.ts";
+export { fleetCapabilities, listFacilitiesCapability, listNodesCapability, listOperatorsCapability, nodesConsoleCapability, } from "./capabilities/fleet.ts";
+export { identityCapabilities, statusCapability, whoamiCapability } from "./capabilities/identity.ts";
+export { createListingCapability, listingCreateInput, listCatalogTermsCapability, listingCapabilities, listListingsCapability, proposeListingCapability, } from "./capabilities/listings.ts";
+export { userCapabilities, usersQueryCapability } from "./capabilities/users.ts";
+export { kubernetesCapabilities, slurmCapabilities } from "./capabilities/clusters.ts";
+export { CLIENTS, parseRole, roleAtLeast, ROLES, type ClientKind, type Role } from "./role.ts";
+export { bindHardwareFields, HARDWARE_CATALOG_PATH, HARDWARE_KINDS, HARDWARE_LISTING_FIELDS, HARDWARE_LISTING_FILTERS, loadHardwareCatalog, looksLikeSpecDump, normalizeCatalogQuery, parseHardwareCatalog, projectCatalogTerms, proposeListingPayload, resolveCatalogTerm, UNRESOLVED_CATALOG_HINT, type CatalogBindResult, type CatalogTerm, type HardwareCatalog, type HardwareKind, type ResolvedCatalogTerm, } from "./spec-catalog.ts";

package/vendor/capabilities/index.js

@@ -0,0 +1,10 @@
+export { byCliCommand, byMcpName, bySlackName, defineCapability, forRole, slackStaffVisible, visibleToClient, } from "./capability.js";
+export { namesFromId } from "./names.js";
+export { catalog } from "./catalog.js";
+export { fleetCapabilities, listFacilitiesCapability, listNodesCapability, listOperatorsCapability, nodesConsoleCapability, } from "./capabilities/fleet.js";
+export { identityCapabilities, statusCapability, whoamiCapability } from "./capabilities/identity.js";
+export { createListingCapability, listingCreateInput, listCatalogTermsCapability, listingCapabilities, listListingsCapability, proposeListingCapability, } from "./capabilities/listings.js";
+export { userCapabilities, usersQueryCapability } from "./capabilities/users.js";
+export { kubernetesCapabilities, slurmCapabilities } from "./capabilities/clusters.js";
+export { CLIENTS, parseRole, roleAtLeast, ROLES } from "./role.js";
+export { bindHardwareFields, HARDWARE_CATALOG_PATH, HARDWARE_KINDS, HARDWARE_LISTING_FIELDS, HARDWARE_LISTING_FILTERS, loadHardwareCatalog, looksLikeSpecDump, normalizeCatalogQuery, parseHardwareCatalog, projectCatalogTerms, proposeListingPayload, resolveCatalogTerm, UNRESOLVED_CATALOG_HINT, } from "./spec-catalog.js";

package/vendor/capabilities/names.d.ts

@@ -0,0 +1,6 @@
+/** Shared wire names derived from `Capability.id`. */
+export declare function namesFromId(id: string): {
+    mcp: string;
+    slack: string;
+    cli: string[];
+};

package/vendor/capabilities/names.js

@@ -0,0 +1,6 @@
+/** Shared wire names derived from `Capability.id`. */
+export function namesFromId(id) {
+    const wire = id.replaceAll(".", "_");
+    const cli = id === "identity.whoami" ? ["whoami"] : id === "identity.status" ? ["status"] : id.split(".");
+    return { mcp: wire, slack: wire, cli };
+}

package/vendor/capabilities/role.d.ts

@@ -0,0 +1,6 @@
+export declare const ROLES: readonly ["user", "reviewer", "admin"];
+export type Role = (typeof ROLES)[number];
+export declare const CLIENTS: readonly ["cli", "mcp", "slack"];
+export type ClientKind = (typeof CLIENTS)[number];
+export declare function roleAtLeast(have: Role, min: Role): boolean;
+export declare function parseRole(raw: unknown): Role | null;

package/vendor/capabilities/role.js

@@ -0,0 +1,17 @@
+export const ROLES = ["user", "reviewer", "admin"];
+export const CLIENTS = ["cli", "mcp", "slack"];
+const ROLE_RANK = {
+    user: 0,
+    reviewer: 1,
+    admin: 2,
+};
+export function roleAtLeast(have, min) {
+    return ROLE_RANK[have] >= ROLE_RANK[min];
+}
+export function parseRole(raw) {
+    if (raw === "admin" || raw === "reviewer" || raw === "user")
+        return raw;
+    if (raw === "operator")
+        return "reviewer";
+    return null;
+}

package/vendor/capabilities/spec-catalog.d.ts

@@ -0,0 +1,78 @@
+import type { CapabilityTransport } from "./capability.ts";
+/** Live orchestrator dictionary: `GET /v1/orchestrator/catalog` from `spec/dictionary.csv`. */
+export declare const HARDWARE_CATALOG_PATH = "/v1/orchestrator/catalog";
+export declare const HARDWARE_KINDS: readonly ["gpu", "cpu", "node", "link"];
+export type HardwareKind = (typeof HARDWARE_KINDS)[number];
+export declare const UNRESOLVED_CATALOG_HINT = "Leave this field empty. Only dictionary.csv product names are allowed. Do not ask to add spec-sheet text to the dictionary.";
+export declare const HARDWARE_LISTING_FIELDS: readonly [{
+    readonly field: "gpu_type";
+    readonly kind: "gpu";
+}, {
+    readonly field: "cpu";
+    readonly kind: "cpu";
+}, {
+    readonly field: "node_model";
+    readonly kind: "node";
+}, {
+    readonly field: "fabric_type";
+    readonly kind: "link";
+}];
+export declare const HARDWARE_LISTING_FILTERS: readonly [{
+    readonly field: "gpu";
+    readonly kind: "gpu";
+}, {
+    readonly field: "cpu";
+    readonly kind: "cpu";
+}, {
+    readonly field: "fabric";
+    readonly kind: "link";
+}];
+export type CatalogTerm = {
+    kind: string;
+    canonical: string;
+    display: string;
+    aliases?: string[];
+    link_category?: string;
+};
+export type HardwareCatalog = {
+    terms: CatalogTerm[];
+};
+export type ResolvedCatalogTerm = {
+    canonical: string | null;
+    display: string | null;
+    hint?: string;
+    kind?: string;
+};
+export type CatalogBindFailure = {
+    ok: false;
+    error: "unknown_catalog_term";
+    rejected: {
+        field: string;
+        value: string;
+    }[];
+    hint: string;
+};
+export type CatalogBindSuccess<T> = {
+    ok: true;
+    payload: T;
+};
+export type CatalogBindResult<T> = CatalogBindSuccess<T> | CatalogBindFailure;
+export declare function looksLikeSpecDump(query: string): boolean;
+export declare function normalizeCatalogQuery(value: string): string;
+export declare function parseHardwareCatalog(payload: unknown): HardwareCatalog;
+export declare function loadHardwareCatalog(fetchImpl: CapabilityTransport): Promise<HardwareCatalog>;
+export declare function resolveCatalogTerm(terms: readonly CatalogTerm[], kind: string, query: string): ResolvedCatalogTerm;
+export declare function bindHardwareFields<T extends Record<string, unknown>>(terms: readonly CatalogTerm[], input: T, fields: readonly {
+    field: string;
+    kind: HardwareKind;
+}[]): CatalogBindResult<T>;
+export declare function proposeListingPayload(terms: readonly CatalogTerm[], args: Record<string, unknown>): CatalogBindResult<Record<string, unknown>> & {
+    action?: "create_listing";
+};
+export declare function projectCatalogTerms(terms: readonly CatalogTerm[], kind?: string): {
+    terms: {
+        kind: string;
+        display: string;
+        aliases: string[];
+    }[];
+};

package/vendor/capabilities/spec-catalog.js

@@ -0,0 +1,128 @@
+/** Live orchestrator dictionary: `GET /v1/orchestrator/catalog` from `spec/dictionary.csv`. */
+export const HARDWARE_CATALOG_PATH = "/v1/orchestrator/catalog";
+export const HARDWARE_KINDS = ["gpu", "cpu", "node", "link"];
+export const UNRESOLVED_CATALOG_HINT = "Leave this field empty. Only dictionary.csv product names are allowed. Do not ask to add spec-sheet text to the dictionary.";
+export const HARDWARE_LISTING_FIELDS = [
+    { field: "gpu_type", kind: "gpu" },
+    { field: "cpu", kind: "cpu" },
+    { field: "node_model", kind: "node" },
+    { field: "fabric_type", kind: "link" },
+];
+export const HARDWARE_LISTING_FILTERS = [
+    { field: "gpu", kind: "gpu" },
+    { field: "cpu", kind: "cpu" },
+    { field: "fabric", kind: "link" },
+];
+export function looksLikeSpecDump(query) {
+    const trimmed = query.trim();
+    if (!trimmed)
+        return false;
+    if ([...trimmed].length > 72)
+        return true;
+    if ((trimmed.match(/,/g) ?? []).length >= 2)
+        return true;
+    const lower = trimmed.toLowerCase();
+    return (lower.includes("ghz") ||
+        lower.includes("tdp") ||
+        lower.includes("gt/s") ||
+        lower.includes("mb cache") ||
+        lower.includes("thread") ||
+        lower.includes("-core") ||
+        lower.includes("core/") ||
+        lower.includes("ddr5") ||
+        lower.includes("ddr4"));
+}
+export function normalizeCatalogQuery(value) {
+    let out = "";
+    let prevSpace = false;
+    for (const ch of value) {
+        const mapped = ch === "×" ? "x" : /[\u2010-\u2014]/.test(ch) ? "-" : ch.toLowerCase();
+        if (/[a-z0-9]/i.test(mapped)) {
+            out += mapped;
+            prevSpace = false;
+        }
+        else if (out && !prevSpace) {
+            out += " ";
+            prevSpace = true;
+        }
+    }
+    return out.trim();
+}
+export function parseHardwareCatalog(payload) {
+    const row = payload && typeof payload === "object" ? payload : null;
+    const raw = Array.isArray(row?.terms) ? row.terms : Array.isArray(payload) ? payload : [];
+    const terms = raw.filter((term) => {
+        if (!term || typeof term !== "object")
+            return false;
+        const candidate = term;
+        return (typeof candidate.kind === "string" &&
+            typeof candidate.canonical === "string" &&
+            typeof candidate.display === "string");
+    });
+    if (!terms.length)
+        throw new Error("catalog terms unavailable");
+    return { terms };
+}
+export async function loadHardwareCatalog(fetchImpl) {
+    return parseHardwareCatalog(await fetchImpl(HARDWARE_CATALOG_PATH, { method: "GET" }));
+}
+export function resolveCatalogTerm(terms, kind, query) {
+    if (looksLikeSpecDump(query) || !normalizeCatalogQuery(query) || !kind.trim()) {
+        return { canonical: null, display: null, hint: UNRESOLVED_CATALOG_HINT };
+    }
+    const needle = normalizeCatalogQuery(query);
+    for (const term of terms) {
+        if (term.kind.toLowerCase() !== kind.toLowerCase())
+            continue;
+        const aliases = [term.display, term.canonical, ...(term.aliases ?? [])];
+        if (aliases.some((alias) => normalizeCatalogQuery(alias) === needle)) {
+            return { canonical: term.canonical, display: term.display, kind: term.kind };
+        }
+    }
+    return { canonical: null, display: null, hint: UNRESOLVED_CATALOG_HINT };
+}
+export function bindHardwareFields(terms, input, fields) {
+    const payload = { ...input };
+    const rejected = [];
+    for (const { field, kind } of fields) {
+        const value = payload[field];
+        if (typeof value !== "string")
+            continue;
+        if (!value.trim()) {
+            delete payload[field];
+            continue;
+        }
+        const resolved = resolveCatalogTerm(terms, kind, value);
+        if (resolved.display) {
+            payload[field] = resolved.display;
+            continue;
+        }
+        rejected.push({ field, value });
+    }
+    if (rejected.length) {
+        return {
+            ok: false,
+            error: "unknown_catalog_term",
+            rejected,
+            hint: "Call listings_catalog_terms and retry with a display name from the dump. Do not ask to add spec-sheet text to the dictionary.",
+        };
+    }
+    return { ok: true, payload };
+}
+export function proposeListingPayload(terms, args) {
+    const bound = bindHardwareFields(terms, args, HARDWARE_LISTING_FIELDS);
+    if (!bound.ok)
+        return bound;
+    return { ok: true, action: "create_listing", payload: bound.payload };
+}
+export function projectCatalogTerms(terms, kind) {
+    return {
+        terms: terms
+            .filter((term) => (kind?.trim() ? term.kind.toLowerCase() === kind.toLowerCase() : true))
+            .map((term) => ({
+            kind: term.kind,
+            display: term.display,
+            aliases: term.aliases ?? [],
+        })),
+    };
+}