feat(inspect gguf command): print a single key flag

Author: giladgd

src/cli/commands/inspect/commands/InspectGgufCommand.ts

@@ -13,10 +13,12 @@ import {documentationPageUrls} from "../../../../config.js";
 import withOra from "../../../../utils/withOra.js";
 import {resolveModelDestination} from "../../../../utils/resolveModelDestination.js";
 import {printModelDestination} from "../../../utils/printModelDestination.js";
+import {getGgufMetadataKeyValue} from "../../../../gguf/utils/getGgufMetadataKeyValue.js";
 
 type InspectGgufCommand = {
     modelPath: string,
     header?: string[],
+    key?: string,
     noSplice: boolean,
     fullTensorInfo: boolean,
     fullMetadataArrays: boolean,
@@ -46,6 +48,12 @@ export const InspectGgufCommand: CommandModule<object, InspectGgufCommand> = {
                 description: "Headers to use when reading a model file from a URL, in the format `key: value`. You can pass this option multiple times to add multiple headers.",
                 group: "Optional:"
             })
+            .option("key", {
+                alias: ["k"],
+                type: "string",
+                description: "A single metadata key to print the value of. If not provided, all metadata will be printed",
+                group: "Optional:"
+            })
             .option("noSplice", {
                 alias: "s",
                 type: "boolean",
@@ -80,7 +88,7 @@ export const InspectGgufCommand: CommandModule<object, InspectGgufCommand> = {
             });
     },
     async handler({
-        modelPath: ggufPath, header: headerArg, noSplice, fullTensorInfo, fullMetadataArrays, plainJson, outputToJsonFile
+        modelPath: ggufPath, header: headerArg, key, noSplice, fullTensorInfo, fullMetadataArrays, plainJson, outputToJsonFile
     }: InspectGgufCommand) {
         const resolvedModelDestination = resolveModelDestination(ggufPath);
         const resolvedGgufPath = resolvedModelDestination.type == "file"
@@ -116,16 +124,30 @@ export const InspectGgufCommand: CommandModule<object, InspectGgufCommand> = {
         const fileTypeName = getGgufFileTypeName(parsedMetadata.metadata.general?.file_type);
 
         if (plainJson || outputToJsonFile != null) {
-            const outputJson = JSON.stringify({
-                splicedParts: parsedMetadata.splicedParts,
-                version: parsedMetadata.version,
-                fileType: fileTypeName,
-                tensorCount: parsedMetadata.totalTensorCount,
-                metadataSize: parsedMetadata.totalMetadataSize,
-                tensorInfoSize: parsedMetadata.totalTensorInfoSize,
-                metadata: parsedMetadata.metadata,
-                tensorInfo: parsedMetadata.fullTensorInfo
-            }, undefined, 4);
+            const getOutputJson = () => {
+                if (key != null) {
+                    const keyValue = getGgufMetadataKeyValue(parsedMetadata.metadata, key);
+                    if (keyValue === undefined) {
+                        console.log(`Key not found: ${key}`);
+                        process.exit(1);
+                    }
+
+                    return JSON.stringify(keyValue, undefined, 4);
+                }
+
+                return JSON.stringify({
+                    splicedParts: parsedMetadata.splicedParts,
+                    version: parsedMetadata.version,
+                    fileType: fileTypeName,
+                    tensorCount: parsedMetadata.totalTensorCount,
+                    metadataSize: parsedMetadata.totalMetadataSize,
+                    tensorInfoSize: parsedMetadata.totalTensorInfoSize,
+                    metadata: parsedMetadata.metadata,
+                    tensorInfo: parsedMetadata.fullTensorInfo
+                }, undefined, 4);
+            };
+
+            const outputJson = getOutputJson();
 
             if (outputToJsonFile != null) {
                 const filePath = path.resolve(process.cwd(), outputToJsonFile);
@@ -134,6 +156,27 @@ export const InspectGgufCommand: CommandModule<object, InspectGgufCommand> = {
             } else {
                 console.info(outputJson);
             }
+        } else if (key != null) {
+            const keyValue = getGgufMetadataKeyValue(parsedMetadata.metadata, key);
+            if (keyValue === undefined) {
+                console.log(`${chalk.red("Metadata key not found:")} ${key}`);
+                process.exit(1);
+            }
+
+            const metadataPrettyPrintOptions: PrettyPrintObjectOptions = {
+                maxArrayValues: fullMetadataArrays
+                    ? undefined
+                    : 10,
+                useNumberGrouping: true,
+                maxArrayItemsWidth: process.stdout.columns - 1
+            };
+
+            console.info(`${chalk.yellow("Metadata key:")} ${prettyPrintObject(key)}`);
+            console.info(`${chalk.yellow("Metadata:")} ${
+                typeof keyValue === "string"
+                    ? keyValue
+                    : prettyPrintObject(keyValue, undefined, metadataPrettyPrintOptions)
+            }`);
         } else {
             const metadataPrettyPrintOptions: PrettyPrintObjectOptions = {
                 maxArrayValues: fullMetadataArrays

src/cli/commands/inspect/commands/InspectGpuCommand.ts

@@ -208,7 +208,7 @@ async function logSwapUsage(llama: Llama) {
     const swapState = await llama.getSwapState();
 
     console.info(`${chalk.yellow("Used swap:")} ${getPercentageString(swapState.used, swapState.allocated)}% ${chalk.gray("(" + bytes(swapState.used) + "/" + bytes(swapState.allocated) + ")")}`);
-    console.info(`${chalk.yellow("Max size:")} ${swapState.maxSize === Infinity ? "dynamic" : bytes(swapState.maxSize)}`);
+    console.info(`${chalk.yellow("Max swap size:")} ${swapState.maxSize === Infinity ? "dynamic" : bytes(swapState.maxSize)}`);
 }
 
 function getPercentageString(amount: number, total: number) {

src/gguf/utils/getGgufMetadataKeyValue.ts

@@ -0,0 +1,34 @@
+export function getGgufMetadataKeyValue(metadata: Record<string, any>, key: string) {
+    return readMedataKey(metadata, key.split("."));
+}
+
+function readMedataKey(metadata: Record<string, any>, keyParts: string[]): any {
+    for (const [metadataKey, value] of Object.entries(metadata)) {
+        const matchLength = checkMatchLength(metadataKey, keyParts);
+        if (matchLength === 0)
+            continue;
+
+        if (matchLength === keyParts.length)
+            return value;
+
+        const res = readMedataKey(value, keyParts.slice(matchLength));
+        if (res !== undefined)
+            return res;
+    }
+
+    return undefined;
+}
+
+function checkMatchLength(metadataKey: string, keyParts: string[]) {
+    const metadataKeyParts = metadataKey.split(".");
+
+    if (metadataKeyParts.length > keyParts.length)
+        return 0;
+
+    for (let i = 0; i < metadataKeyParts.length; i++) {
+        if (metadataKeyParts[i] !== keyParts[i])
+            return 0;
+    }
+
+    return metadataKeyParts.length;
+}