@livingdata/pipex 0.0.8 → 0.0.10

package/dist/cli/commands/exec.js

@@ -0,0 +1,89 @@
+import process from 'node:process';
+import { randomUUID } from 'node:crypto';
+import { dirname, resolve } from 'node:path';
+import { DockerCliExecutor } from '../../engine/docker-executor.js';
+import { Workspace } from '../../engine/workspace.js';
+import { loadStepFile } from '../../core/step-loader.js';
+import { StepRunner } from '../../core/step-runner.js';
+import { StateManager } from '../../core/state.js';
+import { ConsoleReporter } from '../../core/reporter.js';
+import { InteractiveReporter } from '../interactive-reporter.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerExecCommand(program) {
+    program
+        .command('exec')
+        .description('Execute a single step in a workspace')
+        .argument('<workspace>', 'Workspace name')
+        .requiredOption('-f, --file <path>', 'Step definition file (YAML or JSON)')
+        .option('--step <id>', 'Step ID (overrides file\'s id)')
+        .option('--input <specs...>', 'Input steps (e.g. "extract" or "data=extract")')
+        .option('--ephemeral', 'Don\'t commit run, stream stdout to terminal')
+        .option('--force', 'Skip cache check')
+        .option('--verbose', 'Stream container logs in real-time')
+        .action(async (workspaceName, options, cmd) => {
+        const { workdir, json } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const runtime = new DockerCliExecutor();
+        const reporter = json ? new ConsoleReporter() : new InteractiveReporter({ verbose: options.verbose });
+        // Load step from file
+        const stepFilePath = resolve(options.file);
+        const step = await loadStepFile(stepFilePath, options.step);
+        const pipelineRoot = dirname(stepFilePath);
+        // Open or create workspace
+        let workspace;
+        try {
+            workspace = await Workspace.open(workdirRoot, workspaceName);
+        }
+        catch {
+            workspace = await Workspace.create(workdirRoot, workspaceName);
+        }
+        await workspace.cleanupStaging();
+        await runtime.check();
+        await runtime.cleanupContainers(workspace.id);
+        // Load state and resolve inputs
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const inputs = new Map();
+        if (options.input) {
+            for (const spec of options.input) {
+                const { alias, stepId } = parseInputSpec(spec);
+                const stepState = state.getStep(stepId);
+                if (!stepState) {
+                    console.error(`No run found for input step: ${stepId}`);
+                    process.exitCode = 1;
+                    return;
+                }
+                inputs.set(alias, stepState.runId);
+            }
+        }
+        // Merge parsed inputs into step.inputs
+        if (inputs.size > 0 && !step.inputs) {
+            step.inputs = [];
+        }
+        for (const [alias, _runId] of inputs) {
+            // Only add if not already declared in step file
+            if (!step.inputs.some(i => i.step === alias)) {
+                step.inputs.push({ step: alias });
+            }
+        }
+        const job = { workspaceId: workspace.id, jobId: randomUUID() };
+        const runner = new StepRunner(runtime, reporter);
+        await runner.run({
+            workspace,
+            state,
+            step,
+            inputs,
+            pipelineRoot,
+            force: options.force,
+            ephemeral: options.ephemeral,
+            job
+        });
+    });
+}
+function parseInputSpec(spec) {
+    const eqIdx = spec.indexOf('=');
+    if (eqIdx > 0) {
+        return { alias: spec.slice(0, eqIdx), stepId: spec.slice(eqIdx + 1) };
+    }
+    return { alias: spec, stepId: spec };
+}

package/dist/cli/commands/export.js

@@ -0,0 +1,32 @@
+import process from 'node:process';
+import { cp } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { StateManager } from '../../core/state.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerExportCommand(program) {
+    program
+        .command('export')
+        .description('Extract artifacts from a step run to the host filesystem')
+        .argument('<workspace>', 'Workspace name')
+        .argument('<step>', 'Step ID')
+        .argument('<dest>', 'Destination directory')
+        .action(async (workspaceName, stepId, dest, _options, cmd) => {
+        const { workdir } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const workspace = await Workspace.open(workdirRoot, workspaceName);
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const stepState = state.getStep(stepId);
+        if (!stepState) {
+            console.error(chalk.red(`No run found for step: ${stepId}`));
+            process.exitCode = 1;
+            return;
+        }
+        const artifactsPath = workspace.runArtifactsPath(stepState.runId);
+        const destPath = resolve(dest);
+        await cp(artifactsPath, destPath, { recursive: true });
+        console.log(chalk.green(`Exported artifacts from ${stepId} to ${destPath}`));
+    });
+}

package/dist/cli/commands/inspect.js

@@ -0,0 +1,58 @@
+import process from 'node:process';
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { StateManager } from '../../core/state.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerInspectCommand(program) {
+    program
+        .command('inspect')
+        .description('Show metadata from the last run of a step')
+        .argument('<workspace>', 'Workspace name')
+        .argument('<step>', 'Step ID')
+        .action(async (workspaceName, stepId, _options, cmd) => {
+        const { workdir, json } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const workspace = await Workspace.open(workdirRoot, workspaceName);
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const stepState = state.getStep(stepId);
+        if (!stepState) {
+            console.error(chalk.red(`No run found for step: ${stepId}`));
+            process.exitCode = 1;
+            return;
+        }
+        const metaPath = join(workspace.runPath(stepState.runId), 'meta.json');
+        try {
+            const content = await readFile(metaPath, 'utf8');
+            if (json) {
+                console.log(content);
+            }
+            else {
+                const meta = JSON.parse(content);
+                console.log(chalk.bold(`\nRun: ${chalk.cyan(meta.runId)}`));
+                console.log(`  Step:       ${meta.stepId}${meta.stepName ? ` (${meta.stepName})` : ''}`);
+                console.log(`  Status:     ${meta.status === 'success' ? chalk.green('success') : chalk.red('failure')}`);
+                console.log(`  Image:      ${meta.image}`);
+                console.log(`  Command:    ${meta.cmd.join(' ')}`);
+                console.log(`  Duration:   ${meta.durationMs}ms`);
+                console.log(`  Started:    ${meta.startedAt}`);
+                console.log(`  Finished:   ${meta.finishedAt}`);
+                console.log(`  Exit code:  ${meta.exitCode}`);
+                console.log(`  Fingerprint: ${meta.fingerprint}`);
+                if (meta.env && Object.keys(meta.env).length > 0) {
+                    console.log(`  Env:        ${JSON.stringify(meta.env)}`);
+                }
+                if (meta.inputs && meta.inputs.length > 0) {
+                    console.log(`  Inputs:     ${JSON.stringify(meta.inputs)}`);
+                }
+                console.log();
+            }
+        }
+        catch {
+            console.error(chalk.red(`No metadata found for run: ${stepState.runId}`));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/cli/commands/list.js

@@ -0,0 +1,39 @@
+import { resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { dirSize, formatSize } from '../../core/utils.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerListCommand(program) {
+    program
+        .command('list')
+        .alias('ls')
+        .description('List workspaces')
+        .action(async (_options, cmd) => {
+        const { workdir, json } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const names = await Workspace.list(workdirRoot);
+        if (json) {
+            console.log(JSON.stringify(names));
+            return;
+        }
+        if (names.length === 0) {
+            console.log(chalk.gray('No workspaces found.'));
+            return;
+        }
+        const rows = [];
+        for (const name of names) {
+            const ws = await Workspace.open(workdirRoot, name);
+            const runs = await ws.listRuns();
+            const caches = await ws.listCaches();
+            const wsSize = await dirSize(ws.root);
+            rows.push({ name, runs: runs.length, caches: caches.length, size: formatSize(wsSize) });
+        }
+        const nameWidth = Math.max('WORKSPACE'.length, ...rows.map(r => r.name.length));
+        const sizeWidth = Math.max('SIZE'.length, ...rows.map(r => r.size.length));
+        const header = `${'WORKSPACE'.padEnd(nameWidth)}  RUNS  CACHES  ${'SIZE'.padStart(sizeWidth)}`;
+        console.log(chalk.bold(header));
+        for (const row of rows) {
+            console.log(`${row.name.padEnd(nameWidth)}  ${String(row.runs).padStart(4)}  ${String(row.caches).padStart(6)}  ${row.size.padStart(sizeWidth)}`);
+        }
+    });
+}

package/dist/cli/commands/logs.js

@@ -0,0 +1,54 @@
+import process from 'node:process';
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { StateManager } from '../../core/state.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerLogsCommand(program) {
+    program
+        .command('logs')
+        .description('Show logs from the last run of a step')
+        .argument('<workspace>', 'Workspace name')
+        .argument('<step>', 'Step ID')
+        .option('-s, --stream <stream>', 'Show only stdout or stderr', 'both')
+        .action(async (workspaceName, stepId, options, cmd) => {
+        const { workdir } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const workspace = await Workspace.open(workdirRoot, workspaceName);
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const stepState = state.getStep(stepId);
+        if (!stepState) {
+            console.error(chalk.red(`No run found for step: ${stepId}`));
+            process.exitCode = 1;
+            return;
+        }
+        const runDir = workspace.runPath(stepState.runId);
+        if (options.stream === 'both' || options.stream === 'stdout') {
+            try {
+                const stdout = await readFile(join(runDir, 'stdout.log'), 'utf8');
+                if (stdout) {
+                    process.stdout.write(stdout);
+                }
+            }
+            catch {
+                // No stdout log
+            }
+        }
+        if (options.stream === 'both' || options.stream === 'stderr') {
+            try {
+                const stderr = await readFile(join(runDir, 'stderr.log'), 'utf8');
+                if (stderr) {
+                    if (options.stream === 'both') {
+                        console.error(chalk.red('── stderr ──'));
+                    }
+                    process.stderr.write(stderr);
+                }
+            }
+            catch {
+                // No stderr log
+            }
+        }
+    });
+}

package/dist/cli/commands/prune.js

@@ -0,0 +1,26 @@
+import { resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { StateManager } from '../../core/state.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerPruneCommand(program) {
+    program
+        .command('prune')
+        .description('Remove old runs not referenced by current state')
+        .argument('<workspace>', 'Workspace name')
+        .action(async (workspaceName, _options, cmd) => {
+        const { workdir } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const workspace = await Workspace.open(workdirRoot, workspaceName);
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const activeIds = state.activeRunIds();
+        const removed = await workspace.pruneRuns(activeIds);
+        if (removed === 0) {
+            console.log(chalk.gray('No old runs to remove.'));
+        }
+        else {
+            console.log(chalk.green(`Removed ${removed} old run${removed > 1 ? 's' : ''}.`));
+        }
+    });
+}

package/dist/cli/commands/rm-step.js

@@ -0,0 +1,41 @@
+import process from 'node:process';
+import { rm } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { StateManager } from '../../core/state.js';
+import { dirSize, formatSize } from '../../core/utils.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerRmStepCommand(program) {
+    program
+        .command('rm-step')
+        .description('Remove a step\'s run and state entry')
+        .argument('<workspace>', 'Workspace name')
+        .argument('<step>', 'Step ID')
+        .action(async (workspaceName, stepId, _options, cmd) => {
+        const { workdir } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const workspace = await Workspace.open(workdirRoot, workspaceName);
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const stepState = state.getStep(stepId);
+        if (!stepState) {
+            console.error(chalk.red(`No run found for step: ${stepId}`));
+            process.exitCode = 1;
+            return;
+        }
+        const { runId } = stepState;
+        // Measure size before removal
+        const runDir = workspace.runPath(runId);
+        const size = await dirSize(runDir);
+        // Remove run directory
+        await rm(runDir, { recursive: true, force: true });
+        // Remove step-runs symlink
+        const linkPath = join(workspace.root, 'step-runs', stepId);
+        await rm(linkPath, { force: true });
+        // Remove from state
+        state.removeStep(stepId);
+        await state.save();
+        console.log(chalk.green(`Removed step ${chalk.bold(stepId)} (run ${runId}, freed ${formatSize(size)})`));
+    });
+}

package/dist/cli/commands/rm.js

@@ -0,0 +1,27 @@
+import process from 'node:process';
+import { resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerRmCommand(program) {
+    program
+        .command('rm')
+        .description('Remove one or more workspaces')
+        .argument('<workspace...>', 'Workspace names to remove')
+        .action(async (workspaces, _options, cmd) => {
+        const { workdir } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const existing = await Workspace.list(workdirRoot);
+        for (const name of workspaces) {
+            if (!existing.includes(name)) {
+                console.error(chalk.red(`Workspace not found: ${name}`));
+                process.exitCode = 1;
+                return;
+            }
+        }
+        for (const name of workspaces) {
+            await Workspace.remove(workdirRoot, name);
+            console.log(chalk.green(`Removed ${name}`));
+        }
+    });
+}

package/dist/cli/commands/run-bundle.js

@@ -0,0 +1,59 @@
+import process from 'node:process';
+import { readFile, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { DockerCliExecutor } from '../../engine/docker-executor.js';
+import { extractBundle } from '../../core/bundle.js';
+import { PipelineLoader } from '../../core/pipeline-loader.js';
+import { PipelineRunner } from '../../core/pipeline-runner.js';
+import { ConsoleReporter } from '../../core/reporter.js';
+import { InteractiveReporter } from '../interactive-reporter.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerRunBundleCommand(program) {
+    program
+        .command('run-bundle')
+        .description('Execute a pipeline from a bundle archive')
+        .argument('<archive>', 'Bundle archive (.tar.gz)')
+        .option('-w, --workspace <name>', 'Workspace name (for caching)')
+        .option('-f, --force [steps]', 'Skip cache for all steps, or a comma-separated list')
+        .option('--dry-run', 'Validate pipeline and show what would run without executing')
+        .option('--verbose', 'Stream container logs in real-time (interactive mode)')
+        .option('-t, --target <steps>', 'Execute only these steps and their dependencies (comma-separated)')
+        .option('-c, --concurrency <number>', 'Max parallel step executions (default: CPU count)', Number)
+        .action(async (archivePath, options, cmd) => {
+        const { workdir, json } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const archive = await readFile(resolve(archivePath));
+        const extractDir = join(tmpdir(), `pipex-run-bundle-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        try {
+            const pipeline = await extractBundle(archive, extractDir);
+            // Write a pipeline.json so PipelineRunner can load it normally.
+            // The extract directory becomes the pipelineRoot — all relative
+            // host paths in mounts/sources resolve against it.
+            const pipelineFile = join(extractDir, 'pipeline.json');
+            await writeFile(pipelineFile, JSON.stringify(pipeline));
+            const loader = new PipelineLoader();
+            const runtime = new DockerCliExecutor();
+            const reporter = json ? new ConsoleReporter() : new InteractiveReporter({ verbose: options.verbose });
+            const runner = new PipelineRunner(loader, runtime, reporter, workdirRoot);
+            const force = options.force === true
+                ? true
+                : (typeof options.force === 'string' ? options.force.split(',') : undefined);
+            const target = options.target ? options.target.split(',') : undefined;
+            await runner.run(pipelineFile, { workspace: options.workspace, force, dryRun: options.dryRun, target, concurrency: options.concurrency });
+            if (json) {
+                console.log('Pipeline completed');
+            }
+        }
+        catch (error) {
+            if (json) {
+                console.error('Pipeline failed:', error instanceof Error ? error.message : error);
+            }
+            process.exitCode = 1;
+            throw error;
+        }
+        finally {
+            await rm(extractDir, { recursive: true, force: true });
+        }
+    });
+}

package/dist/cli/commands/run.js

@@ -0,0 +1,44 @@
+import { resolve } from 'node:path';
+import { DockerCliExecutor } from '../../engine/docker-executor.js';
+import { PipelineLoader } from '../../core/pipeline-loader.js';
+import { PipelineRunner } from '../../core/pipeline-runner.js';
+import { ConsoleReporter } from '../../core/reporter.js';
+import { InteractiveReporter } from '../interactive-reporter.js';
+import { getGlobalOptions } from '../utils.js';
+export function registerRunCommand(program) {
+    program
+        .command('run')
+        .description('Execute a pipeline')
+        .argument('<pipeline>', 'Pipeline file to execute (JSON or YAML)')
+        .option('-w, --workspace <name>', 'Workspace name (for caching)')
+        .option('-f, --force [steps]', 'Skip cache for all steps, or a comma-separated list (e.g. --force step1,step2)')
+        .option('--dry-run', 'Validate pipeline and show what would run without executing')
+        .option('--verbose', 'Stream container logs in real-time (interactive mode)')
+        .option('-t, --target <steps>', 'Execute only these steps and their dependencies (comma-separated)')
+        .option('-c, --concurrency <number>', 'Max parallel step executions (default: CPU count)', Number)
+        .option('--env-file <path>', 'Load environment variables from a dotenv file for all steps')
+        .action(async (pipelineFile, options, cmd) => {
+        const { workdir, json } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const loader = new PipelineLoader();
+        const runtime = new DockerCliExecutor();
+        const reporter = json ? new ConsoleReporter() : new InteractiveReporter({ verbose: options.verbose });
+        const runner = new PipelineRunner(loader, runtime, reporter, workdirRoot);
+        try {
+            const force = options.force === true
+                ? true
+                : (typeof options.force === 'string' ? options.force.split(',') : undefined);
+            const target = options.target ? options.target.split(',') : undefined;
+            await runner.run(pipelineFile, { workspace: options.workspace, force, dryRun: options.dryRun, target, concurrency: options.concurrency, envFile: options.envFile });
+            if (json) {
+                console.log('Pipeline completed');
+            }
+        }
+        catch (error) {
+            if (json) {
+                console.error('Pipeline failed:', error instanceof Error ? error.message : error);
+            }
+            throw error;
+        }
+    });
+}

package/dist/cli/commands/show.js

@@ -0,0 +1,108 @@
+import process from 'node:process';
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import chalk from 'chalk';
+import { Workspace } from '../../engine/workspace.js';
+import { StateManager } from '../../core/state.js';
+import { dirSize, formatDuration, formatSize } from '../../core/utils.js';
+import { getGlobalOptions } from '../utils.js';
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function registerShowCommand(program) {
+    program
+        .command('show')
+        .description('Show steps and runs in a workspace')
+        .argument('<workspace>', 'Workspace name')
+        .action(async (workspaceName, _options, cmd) => {
+        const { workdir, json } = getGlobalOptions(cmd);
+        const workdirRoot = resolve(workdir);
+        const workspace = await Workspace.open(workdirRoot, workspaceName);
+        const state = new StateManager(workspace.root);
+        await state.load();
+        const steps = state.listSteps();
+        const runningSteps = await workspace.listRunningSteps();
+        const rows = [];
+        let totalSize = 0;
+        for (const { stepId, runId } of steps) {
+            const metaPath = join(workspace.runPath(runId), 'meta.json');
+            try {
+                const content = await readFile(metaPath, 'utf8');
+                const meta = JSON.parse(content);
+                const artifactBytes = await dirSize(workspace.runArtifactsPath(runId));
+                totalSize += artifactBytes;
+                rows.push({
+                    stepId,
+                    stepName: meta.stepName,
+                    status: meta.status,
+                    duration: `${meta.durationMs}ms`,
+                    size: formatSize(artifactBytes),
+                    date: meta.finishedAt.replace('T', ' ').replace(/\.\d+Z$/, ''),
+                    runId
+                });
+            }
+            catch {
+                rows.push({ stepId, status: 'unknown', duration: '-', size: '-', date: '-', runId });
+            }
+        }
+        // Add running steps (not already in committed state)
+        const committedStepIds = new Set(rows.map(r => r.stepId));
+        for (const running of runningSteps) {
+            if (committedStepIds.has(running.stepId)) {
+                continue;
+            }
+            if (!isProcessAlive(running.pid)) {
+                continue;
+            }
+            const elapsedMs = Date.now() - new Date(running.startedAt).getTime();
+            rows.push({
+                stepId: running.stepId,
+                stepName: running.stepName,
+                status: 'running',
+                duration: formatDuration(elapsedMs),
+                size: '-',
+                date: '-',
+                runId: '-'
+            });
+        }
+        if (rows.length === 0) {
+            console.log(chalk.gray('No runs found in this workspace.'));
+            return;
+        }
+        if (json) {
+            console.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+        const stepWidth = Math.max('STEP'.length, ...rows.map(r => (r.stepName ? `${r.stepId} (${r.stepName})` : r.stepId).length));
+        const statusWidth = Math.max('STATUS'.length, ...rows.map(r => r.status.length));
+        const durationWidth = Math.max('DURATION'.length, ...rows.map(r => r.duration.length));
+        const sizeWidth = Math.max('SIZE'.length, ...rows.map(r => r.size.length));
+        const dateWidth = Math.max('FINISHED'.length, ...rows.map(r => r.date.length));
+        console.log(chalk.bold(`${'STEP'.padEnd(stepWidth)}  ${'STATUS'.padEnd(statusWidth)}  ${'DURATION'.padStart(durationWidth)}  ${'SIZE'.padStart(sizeWidth)}  ${'FINISHED'.padEnd(dateWidth)}`));
+        for (const row of rows) {
+            const stepLabel = row.stepName ? `${row.stepId} (${row.stepName})` : row.stepId;
+            const statusColor = row.status === 'success'
+                ? chalk.green
+                : (row.status === 'running' ? chalk.yellow : chalk.red);
+            const statusText = statusColor(row.status);
+            const statusPad = statusWidth + (statusText.length - row.status.length);
+            const cols = [
+                stepLabel.padEnd(stepWidth),
+                statusText.padEnd(statusPad),
+                row.duration.padStart(durationWidth),
+                row.size.padStart(sizeWidth),
+                row.date.padEnd(dateWidth)
+            ];
+            console.log(cols.join('  '));
+        }
+        if (rows.length > 1) {
+            console.log(chalk.gray(`\n  Total: ${formatSize(totalSize)}`));
+        }
+    });
+}

package/dist/cli/condition.js

@@ -0,0 +1,11 @@
+import jexlModule from 'jexl';
+const jexl = new jexlModule.Jexl();
+export async function evaluateCondition(expression, context) {
+    try {
+        const result = await jexl.eval(expression, context);
+        return Boolean(result);
+    }
+    catch {
+        return false;
+    }
+}