@robinpath/cli 1.73.0

package/modules/os.js

@@ -0,0 +1,219 @@
+/**
+ * Native OS module for RobinPath.
+ * Wraps Node.js os module for system information.
+ */
+import {
+    hostname, cpus, totalmem, freemem, networkInterfaces,
+    tmpdir, homedir, type, release, uptime, loadavg,
+    userInfo, platform, arch, endianness, machine, version as osVersion, EOL
+} from 'node:os';
+
+export const OsFunctions = {
+
+    hostname: () => hostname(),
+
+    cpus: () => {
+        return cpus().map(cpu => ({
+            model: cpu.model,
+            speed: cpu.speed,
+            times: cpu.times
+        }));
+    },
+
+    cpuCount: () => cpus().length,
+
+    totalmem: () => totalmem(),
+
+    freemem: () => freemem(),
+
+    usedmem: () => totalmem() - freemem(),
+
+    memoryInfo: () => {
+        const total = totalmem();
+        const free = freemem();
+        return {
+            total,
+            free,
+            used: total - free,
+            percentUsed: Math.round((total - free) / total * 10000) / 100
+        };
+    },
+
+    networkInterfaces: () => {
+        const ifaces = networkInterfaces();
+        const result = {};
+        for (const [name, addrs] of Object.entries(ifaces)) {
+            result[name] = addrs.map(addr => ({
+                address: addr.address,
+                netmask: addr.netmask,
+                family: addr.family,
+                mac: addr.mac,
+                internal: addr.internal,
+                cidr: addr.cidr
+            }));
+        }
+        return result;
+    },
+
+    tmpdir: () => tmpdir(),
+
+    homedir: () => homedir(),
+
+    type: () => type(),
+
+    release: () => release(),
+
+    uptime: () => uptime(),
+
+    loadavg: () => loadavg(),
+
+    userInfo: () => {
+        const info = userInfo();
+        return {
+            username: info.username,
+            uid: info.uid,
+            gid: info.gid,
+            shell: info.shell,
+            homedir: info.homedir
+        };
+    },
+
+    platform: () => platform(),
+
+    arch: () => arch(),
+
+    endianness: () => endianness(),
+
+    machine: () => {
+        if (typeof machine === 'function') return machine();
+        return arch();
+    },
+
+    version: () => {
+        if (typeof osVersion === 'function') return osVersion();
+        return release();
+    },
+
+    eol: () => EOL
+};
+
+export const OsFunctionMetadata = {
+    hostname: {
+        description: 'Get the operating system hostname',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Hostname', example: 'os.hostname'
+    },
+    cpus: {
+        description: 'Get CPU information for each core',
+        parameters: [],
+        returnType: 'array', returnDescription: 'Array of CPU info objects', example: 'os.cpus'
+    },
+    cpuCount: {
+        description: 'Get number of CPU cores',
+        parameters: [],
+        returnType: 'number', returnDescription: 'Number of CPU cores', example: 'os.cpuCount'
+    },
+    totalmem: {
+        description: 'Get total system memory in bytes',
+        parameters: [],
+        returnType: 'number', returnDescription: 'Total memory in bytes', example: 'os.totalmem'
+    },
+    freemem: {
+        description: 'Get free system memory in bytes',
+        parameters: [],
+        returnType: 'number', returnDescription: 'Free memory in bytes', example: 'os.freemem'
+    },
+    usedmem: {
+        description: 'Get used system memory in bytes',
+        parameters: [],
+        returnType: 'number', returnDescription: 'Used memory in bytes', example: 'os.usedmem'
+    },
+    memoryInfo: {
+        description: 'Get detailed memory info (total, free, used, percentUsed)',
+        parameters: [],
+        returnType: 'object', returnDescription: 'Memory info object', example: 'os.memoryInfo'
+    },
+    networkInterfaces: {
+        description: 'Get network interface information',
+        parameters: [],
+        returnType: 'object', returnDescription: 'Object with interface names and address arrays', example: 'os.networkInterfaces'
+    },
+    tmpdir: {
+        description: 'Get the OS temporary directory',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Temp directory path', example: 'os.tmpdir'
+    },
+    homedir: {
+        description: 'Get the current user home directory',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Home directory path', example: 'os.homedir'
+    },
+    type: {
+        description: 'Get the operating system name',
+        parameters: [],
+        returnType: 'string', returnDescription: 'OS name (Linux, Darwin, Windows_NT)', example: 'os.type'
+    },
+    release: {
+        description: 'Get the OS release version',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Release string', example: 'os.release'
+    },
+    uptime: {
+        description: 'Get system uptime in seconds',
+        parameters: [],
+        returnType: 'number', returnDescription: 'Uptime in seconds', example: 'os.uptime'
+    },
+    loadavg: {
+        description: 'Get load averages (1, 5, 15 minute)',
+        parameters: [],
+        returnType: 'array', returnDescription: 'Array of 3 load average numbers', example: 'os.loadavg'
+    },
+    userInfo: {
+        description: 'Get current user information',
+        parameters: [],
+        returnType: 'object', returnDescription: 'Object with username, uid, gid, shell, homedir', example: 'os.userInfo'
+    },
+    platform: {
+        description: 'Get the operating system platform',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Platform (win32, darwin, linux)', example: 'os.platform'
+    },
+    arch: {
+        description: 'Get the CPU architecture',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Architecture (x64, arm64)', example: 'os.arch'
+    },
+    endianness: {
+        description: 'Get CPU endianness',
+        parameters: [],
+        returnType: 'string', returnDescription: 'BE or LE', example: 'os.endianness'
+    },
+    machine: {
+        description: 'Get the machine type',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Machine type string', example: 'os.machine'
+    },
+    version: {
+        description: 'Get the OS version string',
+        parameters: [],
+        returnType: 'string', returnDescription: 'OS version', example: 'os.version'
+    },
+    eol: {
+        description: 'Get the platform-specific end-of-line marker',
+        parameters: [],
+        returnType: 'string', returnDescription: 'EOL string (\\n or \\r\\n)', example: 'os.eol'
+    }
+};
+
+export const OsModuleMetadata = {
+    description: 'Operating system information: hostname, CPUs, memory, network, platform, and more',
+    methods: Object.keys(OsFunctions)
+};
+
+export default {
+    name: 'os',
+    functions: OsFunctions,
+    functionMetadata: OsFunctionMetadata,
+    moduleMetadata: OsModuleMetadata,
+    global: false
+};

package/modules/path.js

@@ -0,0 +1,162 @@
+/**
+ * Native path module for RobinPath.
+ * Wraps Node.js path operations.
+ */
+import { join, resolve, dirname, basename, extname, parse, format, relative, normalize, isAbsolute, sep, delimiter, posix, win32 } from 'node:path';
+import { toStr, requireArgs } from './_helpers.js';
+
+export const PathFunctions = {
+
+    join: (args) => {
+        return join(...args.map(a => toStr(a)));
+    },
+
+    resolve: (args) => {
+        return resolve(...args.map(a => toStr(a)));
+    },
+
+    dirname: (args) => {
+        requireArgs('path.dirname', args, 1);
+        return dirname(toStr(args[0]));
+    },
+
+    basename: (args) => {
+        requireArgs('path.basename', args, 1);
+        const ext = args[1] != null ? toStr(args[1]) : undefined;
+        return basename(toStr(args[0]), ext);
+    },
+
+    extname: (args) => {
+        requireArgs('path.extname', args, 1);
+        return extname(toStr(args[0]));
+    },
+
+    parse: (args) => {
+        requireArgs('path.parse', args, 1);
+        return parse(toStr(args[0]));
+    },
+
+    format: (args) => {
+        requireArgs('path.format', args, 1);
+        const obj = args[0];
+        if (typeof obj !== 'object' || obj === null) {
+            throw new Error('path.format requires an object with root/dir/base/name/ext');
+        }
+        return format(obj);
+    },
+
+    relative: (args) => {
+        requireArgs('path.relative', args, 2);
+        return relative(toStr(args[0]), toStr(args[1]));
+    },
+
+    normalize: (args) => {
+        requireArgs('path.normalize', args, 1);
+        return normalize(toStr(args[0]));
+    },
+
+    isAbsolute: (args) => {
+        requireArgs('path.isAbsolute', args, 1);
+        return isAbsolute(toStr(args[0]));
+    },
+
+    sep: () => sep,
+
+    delimiter: () => delimiter,
+
+    toNamespacedPath: (args) => {
+        requireArgs('path.toNamespacedPath', args, 1);
+        // On Windows, converts to \\?\ prefix; on POSIX, returns unchanged
+        if (process.platform === 'win32') {
+            return '\\\\?\\' + resolve(toStr(args[0]));
+        }
+        return resolve(toStr(args[0]));
+    }
+};
+
+export const PathFunctionMetadata = {
+    join: {
+        description: 'Join path segments together',
+        parameters: [{ name: 'segments', dataType: 'string', description: 'Path segments', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Joined path', example: 'path.join "src" "modules" "test.js"'
+    },
+    resolve: {
+        description: 'Resolve path segments to an absolute path',
+        parameters: [{ name: 'segments', dataType: 'string', description: 'Path segments', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Absolute path', example: 'path.resolve "src" "file.js"'
+    },
+    dirname: {
+        description: 'Get directory name of a path',
+        parameters: [{ name: 'path', dataType: 'string', description: 'File path', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Directory name', example: 'path.dirname "/home/user/file.txt"'
+    },
+    basename: {
+        description: 'Get the last portion of a path',
+        parameters: [
+            { name: 'path', dataType: 'string', description: 'File path', formInputType: 'text', required: true },
+            { name: 'ext', dataType: 'string', description: 'Extension to strip', formInputType: 'text', required: false }
+        ],
+        returnType: 'string', returnDescription: 'Base name', example: 'path.basename "/home/user/file.txt"'
+    },
+    extname: {
+        description: 'Get file extension',
+        parameters: [{ name: 'path', dataType: 'string', description: 'File path', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Extension (e.g. ".txt")', example: 'path.extname "file.txt"'
+    },
+    parse: {
+        description: 'Parse a path into components',
+        parameters: [{ name: 'path', dataType: 'string', description: 'File path', formInputType: 'text', required: true }],
+        returnType: 'object', returnDescription: 'Object with root, dir, base, name, ext', example: 'path.parse "/home/user/file.txt"'
+    },
+    format: {
+        description: 'Format a path object into a string',
+        parameters: [{ name: 'pathObject', dataType: 'object', description: 'Object with root/dir/base/name/ext', formInputType: 'json', required: true }],
+        returnType: 'string', returnDescription: 'Formatted path string', example: 'path.format $obj'
+    },
+    relative: {
+        description: 'Get relative path from one path to another',
+        parameters: [
+            { name: 'from', dataType: 'string', description: 'Base path', formInputType: 'text', required: true },
+            { name: 'to', dataType: 'string', description: 'Target path', formInputType: 'text', required: true }
+        ],
+        returnType: 'string', returnDescription: 'Relative path', example: 'path.relative "/home" "/home/user/file.txt"'
+    },
+    normalize: {
+        description: 'Normalize a path (resolve . and ..)',
+        parameters: [{ name: 'path', dataType: 'string', description: 'Path to normalize', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Normalized path', example: 'path.normalize "/home/user/../file.txt"'
+    },
+    isAbsolute: {
+        description: 'Check if a path is absolute',
+        parameters: [{ name: 'path', dataType: 'string', description: 'Path to check', formInputType: 'text', required: true }],
+        returnType: 'boolean', returnDescription: 'true if absolute', example: 'path.isAbsolute "/home/user"'
+    },
+    sep: {
+        description: 'Get the platform-specific path separator',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Path separator (/ or \\)', example: 'path.sep'
+    },
+    delimiter: {
+        description: 'Get the platform-specific path delimiter',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Path delimiter (: or ;)', example: 'path.delimiter'
+    },
+    toNamespacedPath: {
+        description: 'Convert to namespaced path (Windows \\\\?\\ prefix)',
+        parameters: [{ name: 'path', dataType: 'string', description: 'Path to convert', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'Namespaced path', example: 'path.toNamespacedPath "C:\\Users"'
+    }
+};
+
+export const PathModuleMetadata = {
+    description: 'Path manipulation: join, resolve, parse, format, and platform-aware utilities',
+    methods: Object.keys(PathFunctions)
+};
+
+export default {
+    name: 'path',
+    functions: PathFunctions,
+    functionMetadata: PathFunctionMetadata,
+    moduleMetadata: PathModuleMetadata,
+    global: false
+};

package/modules/process.js

@@ -0,0 +1,214 @@
+/**
+ * Native process module for RobinPath.
+ * Exposes Node.js process information and control.
+ */
+import { toStr, toNum } from './_helpers.js';
+
+export const ProcessFunctions = {
+
+    env: (args) => {
+        if (args.length === 0) return { ...process.env };
+        const key = toStr(args[0]);
+        if (args.length >= 2) {
+            // Set environment variable
+            process.env[key] = toStr(args[1]);
+            return true;
+        }
+        return process.env[key] ?? null;
+    },
+
+    argv: () => {
+        return process.argv.slice(2);
+    },
+
+    exit: (args) => {
+        const code = args.length > 0 ? toNum(args[0], 0) : 0;
+        process.exit(code);
+    },
+
+    cwd: () => {
+        return process.cwd();
+    },
+
+    chdir: (args) => {
+        if (args.length < 1) throw new Error('process.chdir requires a directory path');
+        process.chdir(toStr(args[0]));
+        return process.cwd();
+    },
+
+    pid: () => {
+        return process.pid;
+    },
+
+    ppid: () => {
+        return process.ppid;
+    },
+
+    platform: () => {
+        return process.platform;
+    },
+
+    arch: () => {
+        return process.arch;
+    },
+
+    version: () => {
+        return process.version;
+    },
+
+    versions: () => {
+        return { ...process.versions };
+    },
+
+    memoryUsage: () => {
+        const mem = process.memoryUsage();
+        return {
+            rss: mem.rss,
+            heapTotal: mem.heapTotal,
+            heapUsed: mem.heapUsed,
+            external: mem.external,
+            arrayBuffers: mem.arrayBuffers
+        };
+    },
+
+    uptime: () => {
+        return process.uptime();
+    },
+
+    hrtime: () => {
+        const [s, ns] = process.hrtime();
+        return s * 1e9 + ns;
+    },
+
+    title: (args) => {
+        if (args.length > 0) {
+            process.title = toStr(args[0]);
+        }
+        return process.title;
+    },
+
+    execPath: () => {
+        return process.execPath;
+    },
+
+    cpuUsage: () => {
+        const usage = process.cpuUsage();
+        return { user: usage.user, system: usage.system };
+    },
+
+    resourceUsage: () => {
+        if (typeof process.resourceUsage === 'function') {
+            return process.resourceUsage();
+        }
+        return null;
+    }
+};
+
+export const ProcessFunctionMetadata = {
+    env: {
+        description: 'Get or set environment variables',
+        parameters: [
+            { name: 'key', dataType: 'string', description: 'Variable name (omit to get all)', formInputType: 'text', required: false },
+            { name: 'value', dataType: 'string', description: 'Value to set (omit to get)', formInputType: 'text', required: false }
+        ],
+        returnType: 'any', returnDescription: 'Variable value, all variables, or true on set', example: 'process.env "PATH"'
+    },
+    argv: {
+        description: 'Get command-line arguments',
+        parameters: [],
+        returnType: 'array', returnDescription: 'Array of argument strings', example: 'process.argv'
+    },
+    exit: {
+        description: 'Exit the process with a code',
+        parameters: [{ name: 'code', dataType: 'number', description: 'Exit code (default: 0)', formInputType: 'number', required: false, defaultValue: 0 }],
+        returnType: 'null', returnDescription: 'Does not return', example: 'process.exit 1'
+    },
+    cwd: {
+        description: 'Get current working directory',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Current working directory', example: 'process.cwd'
+    },
+    chdir: {
+        description: 'Change current working directory',
+        parameters: [{ name: 'directory', dataType: 'string', description: 'Directory to change to', formInputType: 'text', required: true }],
+        returnType: 'string', returnDescription: 'New working directory', example: 'process.chdir "/home/user"'
+    },
+    pid: {
+        description: 'Get process ID',
+        parameters: [],
+        returnType: 'number', returnDescription: 'Process ID', example: 'process.pid'
+    },
+    ppid: {
+        description: 'Get parent process ID',
+        parameters: [],
+        returnType: 'number', returnDescription: 'Parent process ID', example: 'process.ppid'
+    },
+    platform: {
+        description: 'Get operating system platform',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Platform (win32, darwin, linux)', example: 'process.platform'
+    },
+    arch: {
+        description: 'Get CPU architecture',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Architecture (x64, arm64, etc.)', example: 'process.arch'
+    },
+    version: {
+        description: 'Get Node.js version',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Version string', example: 'process.version'
+    },
+    versions: {
+        description: 'Get version strings of Node.js and its dependencies',
+        parameters: [],
+        returnType: 'object', returnDescription: 'Object with version strings', example: 'process.versions'
+    },
+    memoryUsage: {
+        description: 'Get memory usage statistics',
+        parameters: [],
+        returnType: 'object', returnDescription: 'Object with rss, heapTotal, heapUsed, external', example: 'process.memoryUsage'
+    },
+    uptime: {
+        description: 'Get process uptime in seconds',
+        parameters: [],
+        returnType: 'number', returnDescription: 'Uptime in seconds', example: 'process.uptime'
+    },
+    hrtime: {
+        description: 'Get high-resolution time in nanoseconds',
+        parameters: [],
+        returnType: 'number', returnDescription: 'Time in nanoseconds', example: 'process.hrtime'
+    },
+    title: {
+        description: 'Get or set process title',
+        parameters: [{ name: 'title', dataType: 'string', description: 'New title (omit to get)', formInputType: 'text', required: false }],
+        returnType: 'string', returnDescription: 'Process title', example: 'process.title "MyApp"'
+    },
+    execPath: {
+        description: 'Get path to the Node.js executable',
+        parameters: [],
+        returnType: 'string', returnDescription: 'Executable path', example: 'process.execPath'
+    },
+    cpuUsage: {
+        description: 'Get CPU usage (user and system microseconds)',
+        parameters: [],
+        returnType: 'object', returnDescription: 'Object with user and system CPU time', example: 'process.cpuUsage'
+    },
+    resourceUsage: {
+        description: 'Get resource usage statistics',
+        parameters: [],
+        returnType: 'object', returnDescription: 'Resource usage object', example: 'process.resourceUsage'
+    }
+};
+
+export const ProcessModuleMetadata = {
+    description: 'Process information and control: env, argv, pid, memory, CPU, and more',
+    methods: Object.keys(ProcessFunctions)
+};
+
+export default {
+    name: 'process',
+    functions: ProcessFunctions,
+    functionMetadata: ProcessFunctionMetadata,
+    moduleMetadata: ProcessModuleMetadata,
+    global: false
+};