feat(model): inspect GGUF and safetensors declarations (#5603)

src/cli/analysisEvidenceDelivery.ts

@@ -1,3 +1,4 @@
+import type { AnalysisViewRequest } from "../domain/analysisView/analysisView.js";
 import { z } from "incur";
 import { parseEvidence, type Evidence } from "../domain/evidence.js";
 import type { JsonValue } from "../domain/jsonValue.js";
@@ -34,6 +35,7 @@ const isEvidence = (value: JsonValue): value is Evidence =>
   "normalized_result" in value;
 
 interface CliEvidenceDelivery {
+  readonly view?: AnalysisViewRequest;
   readonly providerId: string;
   readonly operation: string;
   readonly signal: AbortSignal;
@@ -95,6 +97,7 @@ export const deliverCliAnalysisEvidence = async (
     signal,
     detail,
     evidenceOutput,
+    ...(input.view === undefined ? {} : { view: input.view }),
   });
 };
 
@@ -139,7 +142,7 @@ export const publishCliAnalysisEvidence = async (
       return detail === "summary"
         ? inspectAnalysisView({
             source: { kind: "inline", evidence: complete },
-            view: { kind: "summary" },
+            view: input.view ?? { kind: "summary" },
           })
         : { ok: true as const, value: complete };
     },

src/cli/modelCommands.ts

@@ -0,0 +1,105 @@
+import { inspectModelArtifactInputSchema } from "../domain/model/modelArtifactQuery.js";
+import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { z } from "incur";
+import type { Logger } from "pino";
+import type { CliInstance } from "./types.js";
+import { absoluteCallerPath } from "../filesystem/callerPath.js";
+import { createModelArtifactService } from "../composition/model.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+import {
+  analysisEvidenceDeliveryOptions,
+  deliverCliAnalysisEvidence,
+} from "./analysisEvidenceDelivery.js";
+
+/** One-shot summaries export the same complete observations used by MCP retained pages. */
+export const registerModelCommands = (
+  cli: CliInstance,
+  logger: Logger,
+): void => {
+  cli.command(CLI_COMMANDS.inspectModelArtifact, {
+    description:
+      "Inspect GGUF or safetensors headers without loading model weights",
+    args: z.object({
+      path: z.string().describe("Local model file, detected by content"),
+    }),
+    options: z.object({
+      ...analysisEvidenceDeliveryOptions,
+      view: z
+        .string()
+        .optional()
+        .describe(
+          "JSON model page selection; requires --detail summary and --evidence_output",
+        ),
+      hash: z
+        .enum(["header", "full"])
+        .default("header")
+        .describe(
+          "header reads declarations only; full additionally streams all bytes for SHA-256",
+        ),
+    }),
+    run: ({ args, options }) =>
+      withCommandCancellation((signal) =>
+        logCliCommand(logger, CLI_COMMANDS.inspectModelArtifact, async () => {
+          let view: unknown;
+          try {
+            view =
+              options.view === undefined ? undefined : JSON.parse(options.view);
+          } catch (cause) {
+            return projectAnalysisError(
+              new AnalysisInputError("inspect_model_artifact", { cause }, [
+                {
+                  path: ["view"],
+                  reason: "invalid_format",
+                  message: "view must be a JSON model page selection",
+                },
+              ]),
+            );
+          }
+          const selected = inspectModelArtifactInputSchema.safeParse({
+            path: absoluteCallerPath(args.path),
+            hash: options.hash,
+            detail: options.detail,
+            ...(view === undefined ? {} : { view }),
+          });
+          if (!selected.success)
+            return projectAnalysisError(
+              analysisInputErrorFromIssues(
+                "inspect_model_artifact",
+                selected.error.issues,
+                { view },
+              ),
+            );
+          const service = createModelArtifactService();
+          return deliverCliAnalysisEvidence({
+            run: () =>
+              service.inspect(
+                {
+                  path: absoluteCallerPath(args.path),
+                  hash: options.hash,
+                  detail: "complete",
+                },
+                { signal },
+              ),
+            service,
+            providerId: "model-artifact",
+            operation: "inspect_model_artifact",
+            signal,
+            detail: options.detail,
+            evidenceOutput: options.evidence_output,
+            ...(selected.data.view === undefined
+              ? {}
+              : {
+                  view: {
+                    kind: "model-artifact" as const,
+                    ...selected.data.view,
+                  },
+                }),
+          });
+        }),
+      ),
+  });
+};