@fnndsc/chili 3.2.5

package/dist/index.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+/**
+ * @file Command-line entry point for the chili (ChILI) CLI.
+ *
+ * @module
+ */
+/**
+ * Suppress DEP0169 warning from axios/proxy-from-env dependency.
+ *
+ * This warning originates from the `proxy-from-env` package (version 1.1.0)
+ * used by axios for proxy configuration. The package uses the legacy `url.parse()`
+ * API which is deprecated in favor of the WHATWG URL API.
+ *
+ * Why we suppress it:
+ * - It's a transitive dependency (axios → proxy-from-env) we don't control
+ * - proxy-from-env 1.1.0 is the latest version and hasn't been updated
+ * - According to the warning: "CVEs are not issued for url.parse() vulnerabilities"
+ * - The warning doesn't affect functionality, only console output
+ * - This is a well-known issue in the Node.js ecosystem
+ *
+ * This can be removed once:
+ * - proxy-from-env migrates to WHATWG URL API, OR
+ * - axios replaces proxy-from-env with an alternative
+ *
+ * Tracking: https://github.com/Rob--W/proxy-from-env/issues/51
+ */
+const originalEmitWarning = process.emitWarning;
+process.emitWarning = function (warning, ...args) {
+    // Suppress only the specific DEP0169 warning
+    if (typeof warning === 'string' &&
+        (warning.includes('DEP0169') || warning.includes('url.parse()'))) {
+        return;
+    }
+    // Allow all other warnings through
+    return originalEmitWarning.call(process, warning, ...args);
+};
+import { Command } from "commander";
+import figlet from "figlet";
+import omelette from "omelette";
+import { connectCommand_setup } from "./connect/connectHandler.js";
+import { FeedGroupHandler, FeedMemberHandler } from "./feeds/feedHandler.js";
+import { PluginGroupHandler, PluginMemberHandler, } from "./plugins/pluginHandler.js";
+import { PluginMetaGroupHandler } from "./plugins/pluginMetaHandler.js";
+import { PluginContextGroupHandler } from "./plugins/pluginGroupHandler.js";
+import { inodeCommand_setup } from "./filesystem/inodeCommand.js";
+import { contextCommand_setup } from "./context/contextCommand.js";
+import { pathCommand_setup } from "./path/pathCommand.js";
+import { fileBrowserCommand_setup } from "./filesystem/filesystemHandler.js";
+import { manCommand_setup } from "./man/man.js";
+import { chefsCommand_setup } from "./chefs/chefs.js";
+import { PACSServerGroupHandler } from "./pacs/pacsServerHandler.js";
+import { PACSQueryGroupHandler } from "./pacs/pacsQueryHandler.js";
+import { PACSRetrieveGroupHandler } from "./pacs/pacsRetrieveHandler.js";
+import { chrisConnection_init, NodeStorageProvider, errorStack_getAllOfType } from "@fnndsc/cumin";
+import { FileGroupHandler } from "./filesystem/fileGroupHandler.js";
+const program = new Command();
+program.version("1.0.1").description("A CLI for ChRIS");
+/**
+ * Sets up command completion for the ChILI CLI using omelette.
+ * This provides auto-completion suggestions in the shell.
+ */
+function commandCompletion_setup() {
+    const completion = omelette(`chili|chili`);
+    completion.tree({
+        connect: ["--user", "--password"],
+        man: {
+            doc: [], // We'll populate this later with actual topics
+        },
+        chefs: ["ls", "mkdir", "touch"],
+        plugins: {
+            list: ["--page", "--fields", "--search"],
+            info: ["<pluginId>"],
+            fieldslist: [],
+            delete: ["<IDs>", "--search", "--force"],
+        },
+        feeds: {
+            list: ["--page", "--fields", "--search"],
+            new: ["--name", "--path"],
+            fieldslist: [],
+            delete: ["<IDs>", "--search", "--force"],
+        },
+        inode: {
+            "<path>": {
+                files: {
+                    list: ["--page", "--fields", "--search"],
+                    fieldslist: [],
+                    delete: ["<IDs>", "--search", "--force"],
+                    share: ["--force"],
+                },
+                file: {
+                    view: ["--type"],
+                },
+            },
+        },
+    });
+    completion.on("man.doc", ({ reply }) => {
+        console.log("Autocomplete triggered for man doc command");
+        // We'll implement actual topic retrieval here later
+        reply([]);
+    });
+    completion.init();
+    if (~process.argv.indexOf("--completion")) {
+        completion.setupShellInitFile();
+    }
+}
+/**
+ * Initializes and sets up all command handlers for the ChILI CLI.
+ *
+ * @param program - The Commander.js program instance.
+ */
+async function handlers_initialize() {
+    // const client = await chrisConnection.client_get(); 
+    // We don't enforce connection here to allow --help to work. 
+    // Commands will fail individually if not connected.
+    fileBrowserCommand_setup(program);
+    contextCommand_setup(program);
+    pathCommand_setup(program);
+    manCommand_setup(program);
+    chefsCommand_setup(program);
+    const pacsServerHandler = new PACSServerGroupHandler();
+    pacsServerHandler.pacsServerCommand_setup(program);
+    const pacsQueryHandler = new PACSQueryGroupHandler();
+    pacsQueryHandler.pacsQueryCommand_setup(program);
+    const pacsRetrieveHandler = new PACSRetrieveGroupHandler();
+    pacsRetrieveHandler.pacsRetrieveCommand_setup(program);
+    await inodeCommand_setup(program);
+    const pluginGroupHandler = new PluginGroupHandler();
+    pluginGroupHandler.pluginGroupCommand_setup(program);
+    const pluginMetaGroupHandler = new PluginMetaGroupHandler();
+    pluginMetaGroupHandler.pluginMetaGroupCommand_setup(program);
+    const feedGroupHandler = new FeedGroupHandler();
+    feedGroupHandler.feedGroupCommand_setup(program);
+    const feedMemberHandler = new FeedMemberHandler();
+    feedMemberHandler.feedCommand_setup(program);
+    const pluginMemberHandler = new PluginMemberHandler();
+    pluginMemberHandler.pluginCommand_setup(program);
+    try {
+        const filesGroupHandler = await FileGroupHandler.handler_create("files");
+        filesGroupHandler.fileGroupCommand_setup(program);
+        const linksGroupHandler = await FileGroupHandler.handler_create("links");
+        linksGroupHandler.fileGroupCommand_setup(program);
+        const dirsGroupHandler = await FileGroupHandler.handler_create("dirs");
+        dirsGroupHandler.fileGroupCommand_setup(program);
+    }
+    catch (e) {
+        const err = e instanceof Error ? e.message : String(e);
+        const errors = errorStack_getAllOfType("error");
+        const warnings = errorStack_getAllOfType("warning");
+        console.log(`Note: File group commands (files, dirs, links) are unavailable. Reason: ${err}`);
+        if (errors.length > 0) {
+            console.log("Errors:");
+            errors.forEach(msg => console.log(`  - ${msg}`));
+        }
+        if (warnings.length > 0) {
+            console.log("Warnings:");
+            warnings.forEach(msg => console.log(`  - ${msg}`));
+        }
+    }
+    try {
+        const computesOfPluginHandler = await PluginContextGroupHandler.handler_create("computesofplugin");
+        computesOfPluginHandler.pluginContextGroupCommand_setup(program);
+        const pluginInstancesHandler = await PluginContextGroupHandler.handler_create("instancesofplugin");
+        pluginInstancesHandler.pluginContextGroupCommand_setup(program);
+        const pluginParametersHandler = await PluginContextGroupHandler.handler_create("parametersofplugin");
+        pluginParametersHandler.pluginContextGroupCommand_setup(program);
+    }
+    catch (e) {
+        const err = e instanceof Error ? e.message : String(e);
+        const errors = errorStack_getAllOfType("error");
+        const warnings = errorStack_getAllOfType("warning");
+        console.log(`Note: Plugin context commands are unavailable. Reason: ${err}`);
+        if (errors.length > 0) {
+            console.log("Errors:");
+            errors.forEach(msg => console.log(`  - ${msg}`));
+        }
+        if (warnings.length > 0) {
+            console.log("Warnings:");
+            warnings.forEach(msg => console.log(`  - ${msg}`));
+        }
+    }
+    commandCompletion_setup();
+}
+/**
+ * Parses the command line arguments to extract context information.
+ *
+ * @param args - The command line arguments array (process.argv).
+ * @returns A tuple containing the context string (if found) and the remaining arguments.
+ */
+function context_parse(args) {
+    // Find the first argument that looks like a context string (contains "=" but doesn't start with "-")
+    for (let i = 2; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.includes("=") && !arg.startsWith("-")) {
+            const context = arg;
+            // Reconstruct args without the context string
+            const newArgs = [...args.slice(0, i), ...args.slice(i + 1)];
+            return [context, newArgs];
+        }
+    }
+    return [undefined, args];
+}
+/**
+ * Main function to run the ChILI CLI.
+ * Handles initialization, context parsing, and command execution.
+ */
+async function main() {
+    const nodeStorageProvider = new NodeStorageProvider();
+    const connection = await chrisConnection_init(nodeStorageProvider);
+    const [context, newArgs] = context_parse(process.argv);
+    if (context) {
+        const contextSetSuccess = await connection.context_set(context);
+        if (!contextSetSuccess) {
+            console.error("Failed to set context. Exiting.");
+            process.exit(1);
+        }
+        process.argv = newArgs;
+    }
+    program
+        .name("chili")
+        .description("ChILI handles Intelligent Line Interactions")
+        .option("-v, --verbose", "enable verbose output")
+        .option("-c, --config <path>", "path to config file")
+        .option("-s, --nosplash", "disable splash screen");
+    connectCommand_setup(program);
+    await handlers_initialize(); // Call handlers_initialize here
+    program.parseOptions(process.argv);
+    const options = program.opts();
+    if (!options.nosplash) {
+        console.log(figlet.textSync("ChILI"));
+        console.log("ChILI handles Intelligent Line Interactions");
+    }
+    program.parse(process.argv);
+}
+main().catch((error) => {
+    console.error("An error occurred:", error);
+    process.exit(1);
+});
+// Export utilities for use by other packages (e.g., chell)
+export { logical_toPhysical } from './utils/cli.js';

package/dist/lfs/lfs.d.ts

@@ -0,0 +1,25 @@
+import { Command } from 'commander';
+/**
+ * Lists the contents of a directory with details.
+ *
+ * @param filepath - The directory path to list.
+ */
+export declare function dirContents_list(filepath: string): Promise<void>;
+/**
+ * Creates a directory if it does not exist.
+ *
+ * @param filepath - The directory path to create.
+ */
+export declare function dir_create(filepath: string): void;
+/**
+ * Creates an empty file.
+ *
+ * @param filepath - The file path to create.
+ */
+export declare function file_create(filepath: string): void;
+/**
+ * Sets up the 'lfs' command group in Commander.
+ *
+ * @param program - The Commander program instance.
+ */
+export declare function lfsCommand_setup(program: Command): void;

package/dist/lfs/lfs.js

@@ -0,0 +1,74 @@
+/**
+ * @file Local File System (LFS) Operations.
+ *
+ * This module provides command implementations for interacting with the
+ * local filesystem, mirroring standard shell commands like ls, mkdir, touch.
+ *
+ * @module
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Lists the contents of a directory with details.
+ *
+ * @param filepath - The directory path to list.
+ */
+export async function dirContents_list(filepath) {
+    try {
+        const files = await fs.promises.readdir(filepath);
+        const detailedFilesPromises = files.map(async (file) => {
+            let fileDetails = await fs.promises.lstat(path.resolve(filepath, file));
+            const { size, birthtime } = fileDetails;
+            return { filename: file, "size(KB)": size, created_at: birthtime };
+        });
+        const detailedFiles = await Promise.all(detailedFilesPromises);
+        console.table(detailedFiles);
+    }
+    catch (error) {
+        console.error("Error occurred while reading the directory!", error);
+    }
+}
+/**
+ * Creates a directory if it does not exist.
+ *
+ * @param filepath - The directory path to create.
+ */
+export function dir_create(filepath) {
+    if (!fs.existsSync(filepath)) {
+        fs.mkdirSync(filepath);
+        console.log("The directory has been created successfully");
+    }
+}
+/**
+ * Creates an empty file.
+ *
+ * @param filepath - The file path to create.
+ */
+export function file_create(filepath) {
+    fs.openSync(filepath, "w");
+    console.log("An empty file has been created");
+}
+/**
+ * Sets up the 'lfs' command group in Commander.
+ *
+ * @param program - The Commander program instance.
+ */
+export function lfsCommand_setup(program) {
+    const lfs = program.command('lfs')
+        .description('Local filesystem operations');
+    lfs.command('ls [directory]')
+        .description('List directory contents')
+        .action(async (directory = process.cwd()) => {
+        await dirContents_list(directory);
+    });
+    lfs.command('mkdir <directory>')
+        .description('Create a directory')
+        .action((directory) => {
+        dir_create(path.resolve(process.cwd(), directory));
+    });
+    lfs.command('touch <file>')
+        .description('Create a file')
+        .action((file) => {
+        file_create(path.resolve(process.cwd(), file));
+    });
+}

package/dist/man/man.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Implements the setup for manual/documentation CLI commands.
+ *
+ * This module provides the `manCommand_setup` function which configures
+ * the `man` command group in the main CLI program.
+ *
+ * @module
+ */
+import { Command } from "commander";
+/**
+ * Sets up the 'man' command for displaying ChILI manual and help pages.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export declare function manCommand_setup(program: Command): void;

package/dist/man/man.js

@@ -0,0 +1,31 @@
+import { topics_list } from "../commands/man/topics.js";
+import { manPage_display } from "../commands/man/doc.js";
+/**
+ * Sets up the 'man' command for displaying ChILI manual and help pages.
+ *
+ * @param program - The Commander.js program instance.
+ */
+export function manCommand_setup(program) {
+    const manCommand = program
+        .command("man")
+        .description("ChILI built in manual and help pages");
+    manCommand
+        .command("doc <topic>")
+        .description("Display the manual document for a ChILI topic")
+        .option("-b, --browser", "Open documentation in browser")
+        .option("--style <style>", "Styling for headings", "figlet")
+        .option("--width <N>", "Number of columns in the text response", parseInt)
+        .action(async (topic, options) => {
+        options.topic = topic;
+        await manPage_display(options);
+    });
+    manCommand
+        .command("topics")
+        .description("List the available manual page topics")
+        .action(async () => {
+        const files = await topics_list();
+        console.log("\n\nThe following topics are available:");
+        console.log("(read more with 'chili man doc <topic>')\n");
+        console.log(files.join("\n"));
+    });
+}

package/dist/man/renderer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file AsciiDoc/man page rendering and browser-open helpers.
+ *
+ * @module
+ */
+/**
+ * Determines the root project directory by looking for `package.json`.
+ *
+ * @returns The absolute path to the project directory.
+ */
+export declare function projectDir_get(): string;
+/**
+ * Renders AsciiDoc content to a formatted string for console display.
+ *
+ * @param content - The AsciiDoc content string.
+ * @param style - The rendering style ('figlet' or 'ascii').
+ * @param width - Optional width for text wrapping.
+ * @returns A Promise resolving to the formatted string.
+ */
+export declare function asciidoc_render(content: string, style: "figlet" | "ascii", width?: number): Promise<string>;
+/**
+ * Opens a local file in the default web browser.
+ *
+ * @param filePath - The path to the file to open.
+ */
+export declare function browser_open(filePath: string): void;

package/dist/man/renderer.js

@@ -0,0 +1,187 @@
+/**
+ * @file AsciiDoc/man page rendering and browser-open helpers.
+ *
+ * @module
+ */
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import asciidoctor from "asciidoctor";
+import { exec } from "child_process";
+import os from "os";
+const headingStyles = [
+    { regex: /<h1.*?>(.*?)<\/h1>/g, font: "Standard", color: chalk.magenta },
+    { regex: /<h2.*?>(.*?)<\/h2>/g, font: "Slant", color: chalk.yellow },
+    { regex: /<h3.*?>(.*?)<\/h3>/g, font: "Small", color: chalk.green },
+    { regex: /<h4.*?>(.*?)<\/h4>/g, font: "Mini", color: chalk.blue },
+];
+const asciiHeadingStyles = [
+    {
+        regex: /<h1.*?>(.*?)<\/h1>/g,
+        textTransform: (text) => text.toUpperCase(),
+        color: chalk.yellow,
+    },
+    {
+        regex: /<h2.*?>(.*?)<\/h2>/g,
+        textTransform: (text) => text.toUpperCase(),
+        color: chalk.yellow.italic,
+    },
+    {
+        regex: /<h3.*?>(.*?)<\/h3>/g,
+        textTransform: (text) => text,
+        color: chalk.cyan,
+    },
+    {
+        regex: /<h4.*?>(.*?)<\/h4>/g,
+        textTransform: (text) => text,
+        color: chalk.cyan.italic,
+    },
+];
+/**
+ * Determines the root project directory by looking for `package.json`.
+ *
+ * @returns The absolute path to the project directory.
+ */
+export function projectDir_get() {
+    // Fallback for tests and dev environment
+    let directoryToCheck = process.cwd();
+    while (directoryToCheck) {
+        const packageJsonPath = path.join(directoryToCheck, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            return directoryToCheck;
+        }
+        const parent = path.dirname(directoryToCheck);
+        if (parent === directoryToCheck)
+            break; // Root reached
+        directoryToCheck = parent;
+    }
+    return process.cwd();
+}
+/**
+ * Converts AsciiDoc content to HTML.
+ *
+ * @param content - The AsciiDoc content string.
+ * @returns The converted HTML string.
+ */
+function adoc_htmlConvert(content) {
+    const ascii = asciidoctor();
+    let result = ascii.convert(content, {
+        standalone: false,
+        attributes: {
+            showtitle: "",
+            sectlinks: "",
+            sectanchors: "",
+        },
+    });
+    return result;
+}
+/**
+ * Wraps text to a specified width.
+ *
+ * @param text - The text to wrap.
+ * @param width - The maximum line width.
+ * @returns The wrapped text.
+ */
+function text_wrap(text, width) {
+    if (!width || width <= 0)
+        return text;
+    const words = text.split(" ");
+    let wrappedText = "";
+    let line = "";
+    for (const word of words) {
+        if ((line + word).length > width) {
+            wrappedText += (wrappedText ? "\n" : "") + line.trim();
+            line = "";
+        }
+        line += word + " ";
+    }
+    wrappedText += (wrappedText ? "\n" : "") + line.trim();
+    return wrappedText;
+}
+/**
+ * Renders AsciiDoc content to a formatted string for console display.
+ *
+ * @param content - The AsciiDoc content string.
+ * @param style - The rendering style ('figlet' or 'ascii').
+ * @param width - Optional width for text wrapping.
+ * @returns A Promise resolving to the formatted string.
+ */
+export async function asciidoc_render(content, style, width) {
+    let result = adoc_htmlConvert(content);
+    function ASCII_create(text, style) {
+        const transformedText = style.textTransform(text);
+        return style.color(transformedText);
+    }
+    const heading_process = async (text, style, figletStyle, asciiStyle) => {
+        if (style === "figlet") {
+            // Fallback to simple color as figlet is disabled in this environment
+            return figletStyle.color(text);
+        }
+        else {
+            return ASCII_create(text, asciiStyle);
+        }
+    };
+    for (let i = 0; i < headingStyles.length; i++) {
+        const figletStyle = headingStyles[i];
+        const asciiStyle = asciiHeadingStyles[i];
+        const matches = result.match(figletStyle.regex) || [];
+        for (const match of matches) {
+            const text = match
+                .replace(/<\/?h[1-4].*?>/g, "")
+                .replace(/<a.*?>(.*?)<\/a>/g, "$1");
+            const processed = await heading_process(text, style, figletStyle, asciiStyle);
+            result = result.replace(match, `\n${processed}\n`);
+        }
+    }
+    result = result
+        .replace(/<code>(.*?)<\/code>/g, (_, p1) => chalk.cyan(p1))
+        .replace(/<em>(.*?)<\/em>/g, (_, p1) => chalk.italic(p1))
+        .replace(/<\/div.*?>/g, "")
+        .replace(/<p>(.*?)<\/p>/g, "$1\n")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&amp;/g, "&")
+        .replace(/<a.*?>(.*?)<\/a>/g, "$1")
+        .replace(/<\/?(?!a)[^>]+(>|$)/g, "")
+        .replace(/\n{3,}/g, "\n\n") // Replace 3 or more newlines with 2
+        .trim();
+    // Wrap the result if width is specified
+    if (width) {
+        result = result
+            .split("\n")
+            .map((line) => text_wrap(line, width))
+            .join("\n");
+    }
+    return result;
+}
+/**
+ * Opens a local file in the default web browser.
+ *
+ * @param filePath - The path to the file to open.
+ */
+export function browser_open(filePath) {
+    const ascii = asciidoctor();
+    const tempHtmlPath = path.join(os.tmpdir(), path.basename(filePath).replace(".adoc", ".html"));
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        const html = ascii.convert(content, {
+            safe: "safe",
+            standalone: true,
+            attributes: { showtitle: true },
+        });
+        fs.writeFileSync(tempHtmlPath, html);
+        const command = process.platform === "win32"
+            ? "start"
+            : process.platform === "darwin"
+                ? "open"
+                : "xdg-open";
+        exec(`${command} ${tempHtmlPath}`, (error) => {
+            if (error) {
+                console.error("Error opening browser:", error);
+            }
+        });
+    }
+    catch (error) {
+        console.error("Error opening documentation in browser:", error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/models/feed.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file Models for Feed operations.
+ *
+ * Defines the data structures for ChRIS Feeds.
+ *
+ * @module
+ */
+/**
+ * Represents a ChRIS Feed.
+ */
+export interface Feed {
+    id: number;
+    name: string;
+    creation_date: string;
+    modification_date: string;
+    owner_username?: string;
+    [key: string]: unknown;
+}

package/dist/models/feed.js

@@ -0,0 +1,8 @@
+/**
+ * @file Models for Feed operations.
+ *
+ * Defines the data structures for ChRIS Feeds.
+ *
+ * @module
+ */
+export {};

package/dist/models/listing.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @file Models for file system listings.
+ *
+ * Defines the standardized "View Model" for items appearing in `ls` lists,
+ * regardless of whether they are native files, directories, or virtual plugins.
+ *
+ * @module
+ */
+import { SimpleRecord } from '@fnndsc/cumin';
+/**
+ * Interface representing a rich file system item.
+ * Contains all metadata required for various views (Grid, Long, JSON).
+ */
+export interface ListingItem extends SimpleRecord {
+    /** The display name of the item. */
+    name: string;
+    /** The type of the item. */
+    type: 'dir' | 'file' | 'link' | 'plugin' | 'pipeline' | 'vfs' | 'job';
+    /** Size in bytes. */
+    size: number;
+    /** Username of the owner. */
+    owner: string;
+    /** Creation date (ISO string). */
+    date: string;
+    /** Target path (for links). */
+    target?: string;
+    /** Version string (for plugins). */
+    version?: string;
+    /** Title or description (for feeds, plugin instances). */
+    title?: string;
+    /** Execution status (for job type items). */
+    status?: string;
+}

package/dist/models/listing.js

@@ -0,0 +1,9 @@
+/**
+ * @file Models for file system listings.
+ *
+ * Defines the standardized "View Model" for items appearing in `ls` lists,
+ * regardless of whether they are native files, directories, or virtual plugins.
+ *
+ * @module
+ */
+export {};