@fnndsc/chili 3.2.5

package/dist/pacs/pacsRetrieveHandler.js

@@ -0,0 +1,272 @@
+/**
+ * @file Handler for the PACS retrieve command group.
+ *
+ * @module
+ */
+import { errorStack_getAllOfType, } from "@fnndsc/cumin";
+import { pacsRetrieve_create, pacsRetrieve_delete, pacsRetrieve_statusForQuery, } from "@fnndsc/salsa";
+import { border_draw } from "../screen/screen.js";
+/**
+ * Handler for PACS retrieve commands.
+ */
+export class PACSRetrieveGroupHandler {
+    constructor() {
+        this.assetName = "pacsretrieve";
+    }
+    /**
+     * Setup PACS retrieve commands on the parent command.
+     *
+     * @param program - Commander program instance.
+     */
+    pacsRetrieveCommand_setup(program) {
+        const pacsRetrieveCommand = program
+            .command(this.assetName)
+            .description("Manage PACS retrieves (pull DICOM data from PACS to ChRIS)");
+        // pull command
+        pacsRetrieveCommand
+            .command("pull <queryId>")
+            .description("Trigger a PACS retrieve to pull DICOM data for a query")
+            .action(async (queryIdStr) => {
+            await this.retrieve_pull(queryIdStr);
+        });
+        // report command
+        pacsRetrieveCommand
+            .command("report <queryId>")
+            .description("Show detailed status report for a query retrieve")
+            .action(async (queryIdStr) => {
+            await this.retrieve_report(queryIdStr);
+        });
+        // cancel command
+        pacsRetrieveCommand
+            .command("cancel <retrieveId>")
+            .description("Cancel (delete) a PACS retrieve")
+            .action(async (retrieveIdStr) => {
+            await this.retrieve_cancel(retrieveIdStr);
+        });
+    }
+    /**
+     * Handle the 'pull' command - create a new retrieve.
+     *
+     * @param queryIdStr - Query ID as string.
+     */
+    async retrieve_pull(queryIdStr) {
+        const queryId = Number(queryIdStr);
+        if (Number.isNaN(queryId)) {
+            console.log(border_draw("Query ID must be a number."));
+            return;
+        }
+        const result = await pacsRetrieve_create(queryId);
+        if (!result.ok) {
+            const errors = errorStack_getAllOfType("error");
+            if (errors.length) {
+                errors.forEach((msg) => console.log(border_draw(msg)));
+            }
+            else {
+                console.log(border_draw(`Failed to create PACS retrieve for query ${queryId}.`));
+            }
+            return;
+        }
+        const record = result.value;
+        const msg = [
+            "Created PACS retrieve",
+            `id=${record.id}`,
+            `query=${queryId}`,
+            `status=${record.status || "created"}`,
+        ].join(" ");
+        console.log(border_draw(msg));
+    }
+    /**
+     * Handle the 'report' command - show detailed status.
+     *
+     * @param queryIdStr - Query ID as string.
+     */
+    async retrieve_report(queryIdStr) {
+        const queryId = Number(queryIdStr);
+        if (Number.isNaN(queryId)) {
+            console.log(border_draw("Query ID must be a number."));
+            return;
+        }
+        const result = await pacsRetrieve_statusForQuery(queryId);
+        if (!result.ok) {
+            const errors = errorStack_getAllOfType("error");
+            if (errors.length) {
+                errors.forEach((msg) => console.log(border_draw(msg)));
+            }
+            else {
+                console.log(border_draw(`Failed to generate status report for query ${queryId}.`));
+            }
+            return;
+        }
+        const report = result.value;
+        const rendered = this.report_render(report);
+        console.log(border_draw(rendered));
+    }
+    /**
+     * Handle the 'cancel' command - delete a retrieve.
+     *
+     * @param retrieveIdStr - Retrieve ID as string.
+     */
+    async retrieve_cancel(retrieveIdStr) {
+        const retrieveId = Number(retrieveIdStr);
+        if (Number.isNaN(retrieveId)) {
+            console.log(border_draw("Retrieve ID must be a number."));
+            return;
+        }
+        const result = await pacsRetrieve_delete(retrieveId);
+        if (!result.ok) {
+            const errors = errorStack_getAllOfType("error");
+            if (errors.length) {
+                errors.forEach((msg) => console.log(border_draw(msg)));
+            }
+            else {
+                console.log(border_draw(`Failed to cancel PACS retrieve ${retrieveId}.`));
+            }
+            return;
+        }
+        console.log(border_draw(`PACS retrieve ${retrieveId} cancelled.`));
+    }
+    /**
+     * Determine overall completion status from series statuses.
+     *
+     * @param report - The status report.
+     * @returns True if all series are pulled.
+     */
+    allSeries_arePulled(report) {
+        if (report.studies.length === 0) {
+            return false;
+        }
+        for (const study of report.studies) {
+            for (const series of study.series) {
+                if (series.status !== "pulled") {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    /**
+     * Render a status report into a human-readable string.
+     *
+     * @param report - The status report.
+     * @returns Formatted string.
+     */
+    report_render(report) {
+        const lines = [];
+        lines.push(`Query ID: ${report.queryId}`);
+        if (report.retrieveId !== undefined) {
+            lines.push(`Retrieve ID: ${report.retrieveId}`);
+            // Check if all series are actually pulled (more accurate than retrieve record status)
+            const allPulled = this.allSeries_arePulled(report);
+            const displayStatus = allPulled
+                ? "Completed"
+                : this.status_mapToDisplay(report.retrieveStatus || "unknown");
+            lines.push(`Retrieve Status: ${displayStatus}`);
+        }
+        else {
+            lines.push("Retrieve Status: No retrieve created yet");
+        }
+        lines.push("");
+        if (report.studies.length === 0) {
+            lines.push("No studies found in query result.");
+            return lines.join("\n");
+        }
+        report.studies.forEach((study, idx) => {
+            this.study_renderTo(study, idx + 1, lines);
+        });
+        return lines.join("\n");
+    }
+    /**
+     * Extract value from a DICOM tag object or return as-is.
+     *
+     * @param val - Potentially a tag object with {label, value} or a primitive.
+     * @returns The extracted value.
+     */
+    tagValue_extract(val) {
+        if (val && typeof val === "object" && "value" in val) {
+            const tagObj = val;
+            return String(tagObj.value ?? "");
+        }
+        return String(val ?? "");
+    }
+    /**
+     * Render a single study to the lines array.
+     *
+     * @param study - Study status.
+     * @param studyNum - Study number (1-indexed).
+     * @param lines - Output lines array.
+     */
+    study_renderTo(study, studyNum, lines) {
+        lines.push(`Study ${studyNum}`);
+        const studyDesc = this.tagValue_extract(study.studyDescription);
+        const studyUID = this.tagValue_extract(study.studyInstanceUID);
+        if (studyDesc) {
+            lines.push(`  Description: ${studyDesc}`);
+        }
+        if (studyUID) {
+            lines.push(`  UID: ${studyUID}`);
+        }
+        if (study.series.length === 0) {
+            lines.push("  No series found.");
+            lines.push("");
+            return;
+        }
+        study.series.forEach((series, idx) => {
+            this.series_renderTo(series, idx + 1, lines);
+        });
+        lines.push("");
+    }
+    /**
+     * Render a single series to the lines array.
+     *
+     * @param series - Series status.
+     * @param seriesNum - Series number (1-indexed).
+     * @param lines - Output lines array.
+     */
+    series_renderTo(series, seriesNum, lines) {
+        const seriesDesc = this.tagValue_extract(series.seriesDescription);
+        const description = seriesDesc || `Series ${seriesNum}`;
+        const statusDisplay = this.series_statusDisplay(series);
+        lines.push(`  ${description}: ${statusDisplay}`);
+    }
+    /**
+     * Generate display string for series status.
+     *
+     * @param series - Series status.
+     * @returns Display string.
+     */
+    series_statusDisplay(series) {
+        const { status, actualFiles, expectedFiles } = series;
+        switch (status) {
+            case "pending":
+                return `Pending (0/${expectedFiles} images)`;
+            case "pulling":
+                return `Pulling (${actualFiles}/${expectedFiles} images)`;
+            case "pulled":
+                return `Pulled (${actualFiles} images)`;
+            case "error":
+                return `Error (${actualFiles}/${expectedFiles} images - count mismatch)`;
+            default:
+                return `Unknown (${actualFiles}/${expectedFiles} images)`;
+        }
+    }
+    /**
+     * Map retrieve status to display string.
+     *
+     * @param status - Raw status string.
+     * @returns Display-friendly status.
+     */
+    status_mapToDisplay(status) {
+        switch (status) {
+            case "created":
+                return "Pending";
+            case "sent":
+                return "Retrieving";
+            case "succeeded":
+                return "Completed";
+            case "errored":
+                return "Failed";
+            default:
+                return status;
+        }
+    }
+}

package/dist/pacs/pacsServerHandler.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Handler for the PACS server command group.
+ *
+ * @module
+ */
+import { Command } from "commander";
+/**
+ * Command-group handler for PACS server operations.
+ */
+export declare class PACSServerGroupHandler {
+    private baseGroupHandler;
+    private assetName;
+    constructor();
+    pacsServerCommand_setup(program: Command): void;
+}

package/dist/pacs/pacsServerHandler.js

@@ -0,0 +1,32 @@
+/**
+ * @file Handler for the PACS server command group.
+ *
+ * @module
+ */
+import { ChRISPACSGroup } from "@fnndsc/cumin";
+import { BaseGroupHandler } from "../handlers/baseGroupHandler.js";
+/**
+ * Command-group handler for PACS server operations.
+ */
+export class PACSServerGroupHandler {
+    constructor() {
+        this.assetName = "pacsservers";
+        const chrisObject = new ChRISPACSGroup();
+        this.baseGroupHandler = new BaseGroupHandler(this.assetName, chrisObject);
+    }
+    pacsServerCommand_setup(program) {
+        const pacsServerCommand = program
+            .command(this.assetName)
+            .description("Interact with PACS servers");
+        const listCommand = this.baseGroupHandler.baseListCommand_create(async (options) => {
+            await this.baseGroupHandler.resources_list(options);
+        });
+        pacsServerCommand.addCommand(listCommand);
+        pacsServerCommand
+            .command("fieldslist")
+            .description(`list the ${this.assetName} resource fields`)
+            .action(async () => {
+            await this.baseGroupHandler.resourceFields_list();
+        });
+    }
+}

package/dist/path/pathCommand.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @file Path scan/transfer commands and the recursive ChRIS path scanner.
+ *
+ * @module
+ */
+import { Command } from "commander";
+interface FileInfo {
+    id: number;
+    hostPath: string;
+    chrisPath: string;
+    size: number;
+    isLink: boolean;
+    linkTarget: string;
+    isDirectory: boolean;
+}
+/**
+ * Aggregated result of a recursive ChRIS path scan.
+ */
+export interface ScanRecord {
+    fileInfo: FileInfo[];
+    totalSize: number;
+}
+/**
+ * CLI options controlling a path scan or transfer.
+ */
+export interface CLIscan {
+    tree?: boolean;
+    follow?: boolean;
+    silent?: boolean;
+    hostpath?: string;
+    dirsOnly?: boolean;
+    filter?: string;
+    endsWith?: string;
+    mermaid?: boolean;
+    save?: string;
+}
+/**
+ * Creates an Archy-formatted tree structure from file information.
+ *
+ * @param files - An array of FileInfo objects.
+ * @returns The Archy-formatted tree string.
+ */
+export declare function archyTree_create(files: FileInfo[]): string;
+/**
+ * Performs a recursive scan of the current ChRIS folder.
+ *
+ * @param options - Scan options.
+ * @returns The scan record, or null if no context is set.
+ */
+export declare function scan_do(options: CLIscan): Promise<ScanRecord | null>;
+/**
+ * Formats a number of bytes into a human-readable string.
+ *
+ * @param bytes - The number of bytes.
+ * @returns A formatted string (e.g., "1.23 MB").
+ */
+export declare function bytes_format(bytes: number): string;
+/**
+ * Sets up the 'path' command for performing operations on ChRIS paths.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export declare function pathCommand_setup(program: Command): Promise<void>;
+export {};