@fnndsc/chili 3.2.5

package/dist/utils/input_format.js

@@ -0,0 +1,135 @@
+/**
+ * @file Input Format Detection
+ *
+ * Utilities for detecting the format of plugin input strings (name, Docker image, or store URL).
+ * Used by plugin_add to determine the appropriate registration strategy.
+ *
+ * @module
+ */
+/**
+ * Plugin input format types.
+ */
+import readline from "readline";
+/**
+ * Recognized input formats for plugin add (e.g. docker image, source URL).
+ */
+export var PluginInputFormat;
+(function (PluginInputFormat) {
+    PluginInputFormat["PLUGIN_NAME"] = "plugin_name";
+    PluginInputFormat["DOCKER_IMAGE"] = "docker_image";
+    PluginInputFormat["STORE_URL"] = "store_url";
+})(PluginInputFormat || (PluginInputFormat = {}));
+/**
+ * Detects the format of a plugin input string.
+ *
+ * Determines whether the input is:
+ * - A store URL (starts with http:// or https://)
+ * - A Docker image (contains / or :)
+ * - A plugin name (everything else)
+ *
+ * @param input - The plugin input string to analyze.
+ * @returns DetectedFormat object describing the input type.
+ *
+ * @example
+ * ```typescript
+ * input_detectFormat('pl-dircopy')
+ * // { format: 'plugin_name', value: 'pl-dircopy' }
+ *
+ * input_detectFormat('fnndsc/pl-dircopy:2.1.1')
+ * // { format: 'docker_image', value: 'fnndsc/pl-dircopy:2.1.1', pluginName: 'pl-dircopy', version: '2.1.1' }
+ *
+ * input_detectFormat('https://cube.chrisproject.org/api/v1/plugins/96/')
+ * // { format: 'store_url', value: 'https://...' }
+ * ```
+ */
+export function input_detectFormat(input) {
+    const trimmedInput = input.trim();
+    // Check if it's a URL (store URL)
+    if (trimmedInput.startsWith('http://') || trimmedInput.startsWith('https://')) {
+        return {
+            format: PluginInputFormat.STORE_URL,
+            value: trimmedInput,
+        };
+    }
+    // Check if it's a Docker image (contains / or :)
+    if (trimmedInput.includes('/') || trimmedInput.includes(':')) {
+        const { name, version } = pluginNameAndVersion_extractFromImage(trimmedInput);
+        return {
+            format: PluginInputFormat.DOCKER_IMAGE,
+            value: trimmedInput,
+            pluginName: name,
+            version: version
+        };
+    }
+    // Otherwise, it's a plugin name
+    // Check if it includes version (e.g. pl-dircopy-v2.1.1)
+    if (trimmedInput.includes('-v')) {
+        const lastVIndex = trimmedInput.lastIndexOf('-v');
+        const name = trimmedInput.substring(0, lastVIndex);
+        const version = trimmedInput.substring(lastVIndex + 2); // +2 for '-v'
+        return {
+            format: PluginInputFormat.PLUGIN_NAME,
+            value: name, // Use name without version as value? 
+            // Or keep original? Usually value is used for search.
+            // plugin_add uses detected.value as search term if pluginName is missing.
+            // But we supply pluginName now.
+            // Let's keep value as trimmedInput to be safe, but provide pluginName/version.
+            pluginName: name,
+            version: version
+        };
+    }
+    return {
+        format: PluginInputFormat.PLUGIN_NAME,
+        value: trimmedInput,
+    };
+}
+/**
+ * Extracts a plugin name and version from a Docker image string.
+ *
+ * Examples:
+ *   'fnndsc/pl-dircopy:2.1.1' -> { name: 'pl-dircopy', version: '2.1.1' }
+ *   'fnndsc/pl-dircopy' -> { name: 'pl-dircopy', version: undefined }
+ *   'pl-dircopy:latest' -> { name: 'pl-dircopy', version: 'latest' }
+ *
+ * @param dockerImage - Docker image string.
+ * @returns Object containing extracted plugin name and optional version.
+ */
+export function pluginNameAndVersion_extractFromImage(dockerImage) {
+    // Split by / to get the last part (repository/image)
+    const parts = dockerImage.split('/');
+    const lastPart = parts[parts.length - 1];
+    const nameParts = lastPart.split(':');
+    const name = nameParts[0];
+    const version = nameParts.length > 1 ? nameParts[1] : undefined;
+    return { name, version };
+}
+/**
+ * Backward-compatible helper to extract only the plugin name from a Docker image.
+ *
+ * @param dockerImage - Docker image string.
+ * @returns The extracted plugin name.
+ */
+export function pluginName_extractFromImage(dockerImage) {
+    const { name } = pluginNameAndVersion_extractFromImage(dockerImage);
+    return name;
+}
+/**
+ * Prompts the user for confirmation. Throws if declined or if prompt cannot be shown (non-TTY) without force.
+ *
+ * @param message - The confirmation message to display.
+ */
+export async function prompt_confirmOrThrow(message) {
+    if (!process.stdout.isTTY) {
+        throw new Error(`${message} Use --force to skip confirmation.`);
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const question = (q) => new Promise((resolve) => rl.question(q, resolve));
+    const answer = (await question(`${message} `)).trim().toLowerCase();
+    rl.close();
+    if (answer !== "y" && answer !== "yes") {
+        throw new Error("Operation cancelled by user.");
+    }
+}

package/dist/utils/sort.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @file Generic sorting utilities for list operations.
+ *
+ * Provides type-safe sorting functionality that can be applied to any
+ * array of objects, supporting multiple sort fields and reverse ordering.
+ *
+ * @module
+ */
+import { SimpleRecord } from "@fnndsc/cumin";
+/**
+ * Sorts an array of objects by a specified field.
+ *
+ * @template T - The type of objects in the array.
+ * @param items - Array of objects to sort.
+ * @param sortBy - Field name to sort by.
+ * @param reverse - Whether to reverse the sort order (default: false).
+ * @returns A new sorted array (non-destructive).
+ */
+export declare function items_sort<T extends SimpleRecord>(items: T[], sortBy?: string, reverse?: boolean): T[];
+/**
+ * Applies sorting to a list result based on CLI options.
+ *
+ * @template T - The type of objects in the list.
+ * @param items - Array of items to potentially sort.
+ * @param sortField - Optional field name to sort by.
+ * @param reverse - Whether to reverse the sort order.
+ * @returns Sorted or original array.
+ */
+export declare function list_applySort<T extends SimpleRecord>(items: T[], sortField?: string, reverse?: boolean): T[];

package/dist/utils/sort.js

@@ -0,0 +1,63 @@
+/**
+ * @file Generic sorting utilities for list operations.
+ *
+ * Provides type-safe sorting functionality that can be applied to any
+ * array of objects, supporting multiple sort fields and reverse ordering.
+ *
+ * @module
+ */
+/**
+ * Sorts an array of objects by a specified field.
+ *
+ * @template T - The type of objects in the array.
+ * @param items - Array of objects to sort.
+ * @param sortBy - Field name to sort by.
+ * @param reverse - Whether to reverse the sort order (default: false).
+ * @returns A new sorted array (non-destructive).
+ */
+export function items_sort(items, sortBy, reverse = false) {
+    if (!sortBy || items.length === 0) {
+        return items;
+    }
+    const sorted = [...items].sort((a, b) => {
+        const aVal = a[sortBy];
+        const bVal = b[sortBy];
+        // Handle undefined/null values
+        if (aVal === undefined || aVal === null)
+            return 1;
+        if (bVal === undefined || bVal === null)
+            return -1;
+        let comparison = 0;
+        // Determine comparison based on type
+        if (typeof aVal === 'number' && typeof bVal === 'number') {
+            comparison = aVal - bVal;
+        }
+        else if (typeof aVal === 'string' && typeof bVal === 'string') {
+            comparison = aVal.localeCompare(bVal);
+        }
+        else if (aVal instanceof Date && bVal instanceof Date) {
+            comparison = aVal.getTime() - bVal.getTime();
+        }
+        else {
+            // Fallback: convert to string and compare
+            comparison = String(aVal).localeCompare(String(bVal));
+        }
+        return reverse ? -comparison : comparison;
+    });
+    return sorted;
+}
+/**
+ * Applies sorting to a list result based on CLI options.
+ *
+ * @template T - The type of objects in the list.
+ * @param items - Array of items to potentially sort.
+ * @param sortField - Optional field name to sort by.
+ * @param reverse - Whether to reverse the sort order.
+ * @returns Sorted or original array.
+ */
+export function list_applySort(items, sortField, reverse) {
+    if (!sortField) {
+        return items;
+    }
+    return items_sort(items, sortField, reverse || false);
+}

package/dist/utils/ui.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Prompts the user for a yes/no confirmation.
+ *
+ * @param question - The question to ask.
+ * @returns A Promise resolving to true if the user answers 'y', false otherwise.
+ */
+export declare function prompt_confirm(question: string): Promise<boolean>;

package/dist/utils/ui.js

@@ -0,0 +1,26 @@
+/**
+ * @file User Interface Utilities.
+ *
+ * This module provides helper functions for CLI interactions, such as prompts.
+ *
+ * @module
+ */
+import * as readline from "readline";
+/**
+ * Prompts the user for a yes/no confirmation.
+ *
+ * @param question - The question to ask.
+ * @returns A Promise resolving to true if the user answers 'y', false otherwise.
+ */
+export async function prompt_confirm(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${question} (y/N) `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y");
+        });
+    });
+}

package/dist/utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file Utils exports for chili
+ *
+ * This file exports utility functions without triggering the main CLI.
+ * Used by other packages like chell to import utilities.
+ *
+ * @module
+ */
+export { logical_toPhysical } from './utils/cli.js';
+export { PathMapper, pathMapper_get } from './path/pathMapper.js';
+export type { CacheStats } from './path/pathMapper.js';
+/**
+ * Re-exports connection initialization from cumin to align duplicate package boundaries.
+ */
+export { chrisConnection_init } from '@fnndsc/cumin';

package/dist/utils.js

@@ -0,0 +1,14 @@
+/**
+ * @file Utils exports for chili
+ *
+ * This file exports utility functions without triggering the main CLI.
+ * Used by other packages like chell to import utilities.
+ *
+ * @module
+ */
+export { logical_toPhysical } from './utils/cli.js';
+export { PathMapper, pathMapper_get } from './path/pathMapper.js';
+/**
+ * Re-exports connection initialization from cumin to align duplicate package boundaries.
+ */
+export { chrisConnection_init } from '@fnndsc/cumin';

package/dist/views/compute.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @file View layer for compute resource commands.
+ *
+ * @module
+ */
+import { ComputeResource } from '@fnndsc/cumin';
+/**
+ * Renders a list of compute resources.
+ *
+ * @param resources - Array of ComputeResource objects.
+ * @param options - Output options (table, csv).
+ * @returns Formatted string.
+ */
+export declare function computeList_render(resources: ComputeResource[], options?: {
+    table?: boolean;
+    csv?: boolean;
+}): string;

package/dist/views/compute.js

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+/**
+ * Renders a list of compute resources.
+ *
+ * @param resources - Array of ComputeResource objects.
+ * @param options - Output options (table, csv).
+ * @returns Formatted string.
+ */
+export function computeList_render(resources, options = {}) {
+    if (resources.length === 0)
+        return chalk.gray('No compute resources found.');
+    const fields = ['id', 'name', 'compute_url', 'description'];
+    const headers = ['ID', 'NAME', 'URL', 'DESCRIPTION'];
+    if (options.csv) {
+        const lines = [headers.map((h) => `"${h}"`).join(',')];
+        for (const r of resources) {
+            lines.push(fields.map((f) => `"${r[f] ?? ''}"`).join(','));
+        }
+        return lines.join('\n');
+    }
+    if (options.table) {
+        const colWidths = fields.map((f, i) => Math.max(headers[i].length, ...resources.map((r) => String(r[f] ?? '').length)));
+        const header = headers.map((h, i) => h.padEnd(colWidths[i])).join('  ');
+        const divider = colWidths.map((w) => '─'.repeat(w)).join('  ');
+        const rows = resources.map((r) => fields.map((f, i) => String(r[f] ?? '').padEnd(colWidths[i])).join('  '));
+        return [chalk.bold(header), chalk.gray(divider), ...rows].join('\n');
+    }
+    const termWidth = process.stdout.columns || 120;
+    const urlWidth = 40;
+    const nameWidth = 20;
+    const lines = [];
+    for (const r of resources) {
+        const id = chalk.bold.gray(String(r.id).padStart(4));
+        const name = chalk.cyan(String(r.name).padEnd(nameWidth));
+        const url = chalk.blue(String(r.compute_url ?? '').substring(0, urlWidth).padEnd(urlWidth));
+        const desc = chalk.gray(String(r.description ?? '').substring(0, termWidth - nameWidth - urlWidth - 12));
+        lines.push(`${id}  ${name}  ${url}  ${desc}`);
+    }
+    return lines.join('\n');
+}

package/dist/views/connect.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Renders the result of a login attempt.
+ * @param success - Whether the connection was successful.
+ * @param url - The URL connected to.
+ * @param user - The user logged in as.
+ * @param token - The auth token received (optional, usually not displayed in full).
+ */
+export declare function login_render(success: boolean, url: string, user: string, token?: string): string;
+/**
+ * Renders the result of a logout attempt.
+ * @param success - Whether the logout was successful.
+ */
+export declare function logout_render(success: boolean): string;

package/dist/views/connect.js

@@ -0,0 +1,35 @@
+/**
+ * @file View layer for connection commands.
+ *
+ * Provides standard output formatting for login/logout operations.
+ *
+ * @module
+ */
+import chalk from 'chalk';
+/**
+ * Renders the result of a login attempt.
+ * @param success - Whether the connection was successful.
+ * @param url - The URL connected to.
+ * @param user - The user logged in as.
+ * @param token - The auth token received (optional, usually not displayed in full).
+ */
+export function login_render(success, url, user, token) {
+    if (success) {
+        return chalk.green(`Successfully connected to ${url} as ${user}.`);
+    }
+    else {
+        return chalk.red(`Failed to connect to ${url} as ${user}.`);
+    }
+}
+/**
+ * Renders the result of a logout attempt.
+ * @param success - Whether the logout was successful.
+ */
+export function logout_render(success) {
+    if (success) {
+        return chalk.green('Logged out from ChRIS.');
+    }
+    else {
+        return chalk.red('Logout failed.');
+    }
+}

package/dist/views/feed.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file View layer for Feed commands.
+ *
+ * Provides output formatting for feed listing and creation.
+ *
+ * @module
+ */
+import { SimpleRecord } from '@fnndsc/cumin';
+import { Feed } from '../models/feed.js';
+import type { FeedNote } from '../commands/feed/note.js';
+import type { FeedComment } from '../commands/feed/comments.js';
+/**
+ * Options for rendering output.
+ */
+export interface OutputOptions {
+    table?: boolean;
+    csv?: boolean;
+}
+/**
+ * Renders a list of feeds.
+ * @param feeds - Array of Feed objects.
+ * @param selectedFields - The fields to display, in order.
+ * @param options - Output options (e.g., table, csv).
+ */
+export declare function feedList_render(feeds: Feed[], selectedFields: string[], options?: OutputOptions): string;
+/**
+ * Renders the result of feed creation.
+ * @param feedRecord - The created feed record (SimpleRecord).
+ */
+export declare function feedCreate_render(feedRecord: SimpleRecord): string;
+/**
+ * Renders a feed note.
+ *
+ * @param note - Note data.
+ * @param feedId - Feed ID for context header.
+ */
+export declare function feedNote_render(note: FeedNote, feedId: number): string;
+/**
+ * Renders a list of feed comments.
+ *
+ * @param comments - Array of comments.
+ * @param feedId - Feed ID for context header.
+ */
+export declare function feedComments_render(comments: FeedComment[], feedId: number): string;

package/dist/views/feed.js

@@ -0,0 +1,110 @@
+import chalk from 'chalk';
+import { screen } from '../screen/screen.js';
+/**
+ * Renders a list of feeds.
+ * @param feeds - Array of Feed objects.
+ * @param selectedFields - The fields to display, in order.
+ * @param options - Output options (e.g., table, csv).
+ */
+export function feedList_render(feeds, selectedFields, options = {}) {
+    if (feeds.length === 0)
+        return chalk.gray("No feeds found.");
+    // Define default fields if none are specified or if the fields are empty
+    const effectiveFields = selectedFields.length > 0 ? selectedFields : ['id', 'name', 'creation_date', 'owner_username'];
+    const rows = feeds.map(f => {
+        return effectiveFields.map(field => {
+            const fieldKey = field;
+            const rawValue = f[fieldKey];
+            let value = rawValue !== undefined && rawValue !== null ? String(rawValue) : '';
+            // Apply basic styling for key fields only in non-CSV/non-Table output
+            if (!options.csv && !options.table) {
+                if (field === 'id')
+                    return chalk.bold(value);
+                if (field === 'name')
+                    return chalk.cyan(value);
+            }
+            if (field === 'creation_date' && value.length > 19)
+                return value.substring(0, 19); // Truncate ISO string
+            return value;
+        });
+    });
+    const headerForDisplay = effectiveFields.map(field => field.toUpperCase());
+    if (options.csv) {
+        // CSV format
+        const csvHeader = headerForDisplay.map(h => `"${h}"`).join(',');
+        const csvRows = rows.map(row => row.map(cell => `"${String(cell).split('"').join('""')}"`).join(',')).join('\n'); // Fixed CSV escaping
+        return [csvHeader, csvRows].join('\n');
+    }
+    else if (options.table) {
+        const tableDataForScreen = feeds.map(feed => {
+            const row = {};
+            effectiveFields.forEach(field => {
+                const fieldKey = field;
+                const val = feed[fieldKey];
+                row[field] = val !== undefined && val !== null ? val : '';
+            });
+            return row;
+        });
+        // Pass original effectiveFields as head for correct data mapping, headerForDisplay for title
+        return screen.table_output(tableDataForScreen, {
+            head: effectiveFields,
+            title: { title: "Feeds", justification: "center" },
+            typeColors: {
+                string: "green",
+                number: "yellow",
+                boolean: "cyan",
+                object: "magenta"
+            }
+        });
+    }
+    else {
+        // Default list format (tab-separated)
+        return rows.map(row => row.join('\t')).join('\n');
+    }
+}
+/**
+ * Renders the result of feed creation.
+ * @param feedRecord - The created feed record (SimpleRecord).
+ */
+export function feedCreate_render(feedRecord) {
+    return chalk.green(`Feed created successfully.\nID: ${feedRecord.id}\nName: ${feedRecord.name}`);
+}
+/**
+ * Renders a feed note.
+ *
+ * @param note - Note data.
+ * @param feedId - Feed ID for context header.
+ */
+export function feedNote_render(note, feedId) {
+    const lines = [
+        chalk.bold.cyan(`Note for feed ${feedId}`),
+        chalk.gray('─'.repeat(40)),
+    ];
+    if (note.title)
+        lines.push(`${chalk.bold('Title:')}   ${note.title}`);
+    lines.push(`${chalk.bold('Content:')} ${note.content || chalk.gray('(empty)')}`);
+    return lines.join('\n');
+}
+/**
+ * Renders a list of feed comments.
+ *
+ * @param comments - Array of comments.
+ * @param feedId - Feed ID for context header.
+ */
+export function feedComments_render(comments, feedId) {
+    if (comments.length === 0) {
+        return chalk.gray(`No comments on feed ${feedId}.`);
+    }
+    const lines = [
+        chalk.bold.cyan(`Comments on feed ${feedId}`) + chalk.gray(` (${comments.length})`),
+        chalk.gray('─'.repeat(50)),
+    ];
+    for (const c of comments) {
+        lines.push(`${chalk.bold.gray(String(c.id).padStart(4))}  ` +
+            `${chalk.cyan(c.owner_username.padEnd(16))}  ` +
+            `${chalk.bold(c.title || chalk.gray('(no title)'))}`);
+        if (c.content)
+            lines.push(`      ${chalk.white(c.content)}`);
+    }
+    return lines.join('\n');
+}

package/dist/views/file.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Options for rendering output.
+ */
+export interface OutputOptions {
+    table?: boolean;
+    csv?: boolean;
+}
+/**
+ * Represents a file resource item.
+ */
+export interface FileResource {
+    id?: number;
+    fname?: string;
+    fsize?: number;
+    owner_username?: string;
+    creation_date?: string;
+    [key: string]: string | number | boolean | null | undefined;
+}
+/**
+ * Renders a list of files.
+ * @param files - Array of file resource objects.
+ * @param selectedFields - The fields to display, in order.
+ * @param options - Output options (e.g., table, csv).
+ */
+export declare function fileList_render(files: FileResource[], selectedFields: string[], options?: OutputOptions): string;

package/dist/views/file.js

@@ -0,0 +1,71 @@
+/**
+ * @file View layer for File commands.
+ *
+ * Provides output formatting for file listing (files, dirs, links).
+ *
+ * @module
+ */
+import chalk from 'chalk';
+import { screen } from '../screen/screen.js';
+/**
+ * Renders a list of files.
+ * @param files - Array of file resource objects.
+ * @param selectedFields - The fields to display, in order.
+ * @param options - Output options (e.g., table, csv).
+ */
+export function fileList_render(files, selectedFields, options = {}) {
+    if (files.length === 0)
+        return chalk.gray("No files found.");
+    // Define default fields if none are specified or if the fields are empty
+    const effectiveFields = selectedFields.length > 0
+        ? selectedFields
+        : ['id', 'fname', 'fsize', 'owner_username', 'creation_date'];
+    const rows = files.map(f => {
+        return effectiveFields.map(field => {
+            const rawValue = f[field];
+            let value = rawValue !== undefined && rawValue !== null ? String(rawValue) : '';
+            // Apply basic styling for key fields only in non-CSV/non-Table output
+            if (!options.csv && !options.table) {
+                if (field === 'id')
+                    return chalk.bold(value);
+                if (field === 'fname')
+                    return chalk.cyan(value);
+            }
+            if (field === 'creation_date' && value.length > 19)
+                return value.substring(0, 19);
+            return value;
+        });
+    });
+    const headerForDisplay = effectiveFields.map(field => field.toUpperCase());
+    if (options.csv) {
+        // CSV format
+        const csvHeader = headerForDisplay.map(h => `"${h}"`).join(',');
+        const csvRows = rows.map(row => row.map(cell => `"${String(cell).split('"').join('""')}"`).join(',')).join('\n');
+        return [csvHeader, csvRows].join('\n');
+    }
+    else if (options.table) {
+        // Prepare data for screen.table_output
+        const tableDataForScreen = files.map(file => {
+            const row = {};
+            effectiveFields.forEach(field => {
+                const val = file[field];
+                row[field] = val !== undefined && val !== null ? val : '';
+            });
+            return row;
+        });
+        return screen.table_output(tableDataForScreen, {
+            head: effectiveFields,
+            title: { title: "Files", justification: "center" },
+            typeColors: {
+                string: "green",
+                number: "yellow",
+                boolean: "cyan",
+                object: "magenta"
+            }
+        });
+    }
+    else {
+        // Default list format (no header)
+        return rows.map(row => row.join('\t')).join('\n');
+    }
+}