@jujulego/jill 2.5.2 → 3.0.0-alpha.10

package/dist/main.js

@@ -1,46 +1,1977 @@
-import { Logger } from '@jujulego/logger';
+;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d71a4689-40f0-48b6-8162-43fd470f2d95",e._sentryDebugIdIdentifier="sentry-dbid-d71a4689-40f0-48b6-8162-43fd470f2d95");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.10"};}catch(e){}}();import { token$, inject$, asyncScope$ } from '@kyrielle/injector';
+import { startInactiveSpan, startSpan, getActiveSpan, updateSpanName, getRootSpan, captureException } from '@sentry/node';
+import { filter$, waitFor$, pipe$, map$, collect$, asyncIterator$, var$, flow$ } from 'kyrielle';
+import process$1 from 'node:process';
 import { hideBin } from 'yargs/helpers';
-import { m as container, E as ExitException } from './ink-command-S3TpJLFi.js';
-import { J as JillApplication } from './jill.application-CGujSe1_.js';
-import '@swc/helpers/_/_ts_decorate';
-import '@swc/helpers/_/_ts_param';
-import 'inversify';
-import 'node:async_hooks';
-import '@jujulego/tasks';
-import 'node:os';
-import 'node:path';
-import 'ajv';
-import 'node:worker_threads';
-import 'yargs';
-import 'cosmiconfig';
-import 'react/jsx-runtime';
-import 'ink';
-import 'ink-spinner';
-import 'log-symbols';
-import 'pretty-ms';
-import 'react';
-import '@jujulego/event-tree';
-import 'inversify-inject-decorators';
-import '@jujulego/aegis';
-import '@jujulego/quick-tag';
-import 'chalk-template';
+import { scheduler$, isWorkloadEnded, WorkloadState, spawn$, parallelFlow$, fallbackFlow$, sequenceFlow$ } from '@jujulego/tasks';
+import { logger$, withTimestamp, LogLevel, withLabel, qLogDelay, LogGateway, logDelay$, toStderr } from '@kyrielle/logger';
+import { _ } from '@swc/helpers/_/_apply_decs_2203_r';
+import { text } from 'node:stream/consumers';
+import fs from 'node:fs';
+import { PathScurry } from 'path-scurry';
+import assert from 'assert';
+import { Writable } from 'node:stream';
+import moo from 'moo';
+import path from 'node:path';
+import { Glob } from 'glob';
+import normalize from 'normalize-package-data';
+import { satisfies, compare, parse } from 'semver';
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+import slugify from 'slugify';
+import yargs from 'yargs';
+import { qjson, qprop, q$, defineQuickFormat, qerror, qarg, qwrap } from '@jujulego/quick-tag';
+import Ajv from 'ajv';
+import os from 'node:os';
+import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
+import { chalkTemplateStderr } from 'chalk-template';
 
-// Bootstrap
-(async ()=>{
-    const app = await container.getAsync(JillApplication);
+// Filter
+function hasSomeScript$(scripts) {
+    return filter$((wks)=>{
+        if (!wks.manifest.scripts) {
+            return false;
+        }
+        return scripts.some((script)=>script in wks.manifest.scripts);
+    });
+}
+function hasEveryScript$(scripts) {
+    return filter$((wks)=>{
+        if (!wks.manifest.scripts) {
+            return false;
+        }
+        return scripts.every((script)=>script in wks.manifest.scripts);
+    });
+}
+
+// Tokens
+const CONFIG = token$('Config', async ()=>{
+    const { ConfigService } = await Promise.resolve().then(function () { return config_service; });
+    return waitFor$(inject$(ConfigService, asyncScope$()).config$);
+});
+const CWD = token$('cwd', ()=>process$1.cwd());
+const LOGGER = token$('Logger', ()=>logger$(withTimestamp()));
+const PATH_SCURRY = token$('PathScurry', ()=>new PathScurry('/', {
+        fs
+    }));
+const SCHEDULER = token$('Scheduler', async ()=>{
+    const config = await inject$(CONFIG, asyncScope$());
+    const logger = inject$(LOGGER);
+    const scheduler = scheduler$({
+        strength: config.jobs
+    });
+    scheduler.events$.on('started', (job)=>{
+        logger.verbose(`job "${job.label}" started`);
+    });
+    scheduler.events$.on('ended', (job)=>{
+        logger.verbose(`job "${job.label}" ended in state ${job.state()}`);
+    });
+    // Task instrumentation
+    scheduler.events$.on('added', (job)=>{
+        const jobSpan = startInactiveSpan({
+            op: 'job',
+            name: job.label,
+            attributes: {
+                'job.id': job.id,
+                'job.type': job.type,
+                'job.weight': job.weight
+            }
+        });
+        // Status spans
+        let stateSpan;
+        let subscription;
+        job.state$.subscribe({
+            start: (sub)=>{
+                subscription = sub;
+            },
+            next: (state)=>{
+                stateSpan?.end();
+                if (isWorkloadEnded(state)) {
+                    jobSpan.setAttribute('job.final_state', state);
+                    jobSpan.setAttribute('job.duration', job.duration().seconds());
+                    jobSpan.setStatus({
+                        code: state === WorkloadState.Succeeded ? 1 : 2
+                    });
+                    jobSpan.end();
+                    subscription.unsubscribe();
+                } else {
+                    stateSpan = startInactiveSpan({
+                        op: 'job.state',
+                        name: state,
+                        parentSpan: jobSpan
+                    });
+                }
+            }
+        });
+    });
+    return scheduler;
+});
+
+function trace(fun, opts) {
+    const name = typeof opts === 'string' ? opts : opts.name;
+    const op = typeof opts === 'object' ? opts.op : undefined;
+    const use = typeof opts === 'object' && opts.use || ((_, r)=>r);
+    return function(...args) {
+        return pipe$(startSpan({
+            name,
+            op
+        }, ()=>fun.call(this, ...args)), (r)=>use(name, r));
+    };
+}
+function instrument(opts) {
+    return (target, context)=>{
+        const name = typeof opts === 'string' ? opts : opts?.name ?? context.name.toString();
+        const use = typeof opts === 'object' ? opts.use : (_, r)=>r;
+        return trace(target, {
+            name,
+            use
+        });
+    };
+}
+function traceImport(name, loader) {
+    return startSpan({
+        name: name,
+        op: 'resource.script'
+    }, loader);
+}
+
+class ClientError extends Error {
+    name = 'ClientError';
+    constructor(message){
+        super(message);
+    }
+}
+class TaskExpressionError extends ClientError {
+    name = 'TaskExpressionError';
+}
+class TaskSyntaxError extends ClientError {
+    name = 'TaskSyntaxError';
+}
+
+function logStreamedLines(logger, level) {
+    let leftover = '';
+    return new Writable({
+        write (chunk, _, cb) {
+            assert(chunk instanceof Buffer);
+            const data = leftover + chunk.toString('utf-8');
+            const lines = data.split(/\r?\n/);
+            leftover = lines.pop() ?? '';
+            for (const line of lines){
+                logger.log(level, line);
+            }
+            cb();
+        },
+        final (cb) {
+            if (leftover !== '') {
+                logger.log(level, leftover);
+            }
+            cb();
+        }
+    });
+}
+
+var _dec$2, _dec1$1, _dec2, _initProto$2;
+_dec$2 = instrument('GitService.isAffected'), _dec1$1 = instrument('GitService.listBranches'), _dec2 = instrument('GitService.listTags');
+class GitService {
+    static{
+        ({ e: [_initProto$2] } = _(this, [
+            [
+                _dec$2,
+                2,
+                "isAffected"
+            ],
+            [
+                _dec1$1,
+                2,
+                "listBranches"
+            ],
+            [
+                _dec2,
+                2,
+                "listTags"
+            ]
+        ], []));
+    }
+    // Attributes
+    _scheduler = (_initProto$2(this), inject$(SCHEDULER));
+    _logger = inject$(LOGGER);
+    // Methods
+    /**
+   * Runs a git command inside
+   */ async command(cmd, args, opts = {}) {
+        const { logger = this._logger, ...props } = opts;
+        // Create job
+        const job = spawn$('git', [
+            cmd,
+            ...args
+        ], props);
+        job.stdout.pipe(logStreamedLines(logger, LogLevel.debug));
+        job.stderr.pipe(logStreamedLines(logger, LogLevel.warning));
+        (await this._scheduler).register(job);
+        return job;
+    }
+    /**
+   * Runs git branch
+   */ branch(args, opts) {
+        return this.command('branch', args, opts);
+    }
+    /**
+   * Runs git diff
+   */ diff(args, opts) {
+        return this.command('diff', args, opts);
+    }
+    /**
+   * Runs git tag
+   */ tag(args, opts) {
+        return this.command('tag', args, opts);
+    }
+    /**
+   * Uses git diff to detect if given files have been affected since given reference
+   */ async isAffected(reference, files = [], opts) {
+        const job = await this.diff([
+            '--quiet',
+            reference,
+            '--',
+            ...files
+        ], opts);
+        await waitFor$(pipe$(job.state$, filter$(isWorkloadEnded)));
+        if (job.exitCode() === 0) {
+            return false;
+        }
+        if (job.exitCode() === 1) {
+            return true;
+        }
+        throw new ClientError(`Error "git diff" command failed (exit code ${job.exitCode()})`);
+    }
+    /**
+   * List git branches
+   */ async listBranches(args = [], opts) {
+        const job = await this.branch([
+            '-l',
+            ...args
+        ], opts);
+        const output = await text(job.stdout);
+        return pipe$(output.split(/\r?\n/), map$((line)=>line.replace(/^[ *] /, '')), filter$((line)=>!!line), collect$());
+    }
+    /**
+   * List git tags
+   */ async listTags(args = [], opts) {
+        const job = await this.tag([
+            '-l',
+            ...args
+        ], opts);
+        const output = await text(job.stdout);
+        return output.split(/\r?\n/).filter((line)=>!!line);
+    }
+}
+
+// Filter
+function isAffected$(opts) {
+    return (origin)=>{
+        return asyncIterator$(async function*() {
+            for await (const wks of origin){
+                const revision = await formatRevision(opts, wks);
+                if (await wks.isAffected(revision)) {
+                    yield wks;
+                }
+            }
+        }());
+    };
+}
+async function formatRevision(opts, workspace) {
+    const git = inject$(GitService);
+    const logger = inject$(LOGGER).child(withLabel(workspace.name));
+    // Format revision
+    let result = opts.format;
+    result = result.replace(/(?<!\\)((?:\\\\)*)%name/g, `$1${workspace.name}`);
+    result = result.replace(/\\(.)/g, '$1');
+    // Ask git to complete it
+    const sortArgs = opts.sort ? [
+        '--sort',
+        opts.sort
+    ] : [];
+    // - search in branches
+    if (result.includes('*')) {
+        const branches = await git.listBranches([
+            ...sortArgs,
+            result
+        ], {
+            cwd: workspace.root,
+            logger: logger
+        });
+        if (branches.length > 0) {
+            result = branches[branches.length - 1];
+        }
+    }
+    // - search in tags
+    if (result.includes('*')) {
+        const tags = await git.listTags([
+            ...sortArgs,
+            result
+        ], {
+            cwd: workspace.root,
+            logger: logger
+        });
+        if (tags.length > 0) {
+            result = tags[tags.length - 1];
+        }
+    }
+    if (result !== opts.format) {
+        logger.verbose(`resolved ${opts.format} into ${result}`);
+    }
+    if (result.includes('*')) {
+        logger.warning(`no revision found matching ${result}, using fallback ${opts.fallback}`);
+        return opts.fallback;
+    }
+    return result;
+}
+
+// Filter
+function isPrivate$(value) {
+    return filter$((wks)=>(wks.manifest.private ?? false) === value);
+}
+
+var _dec$1, _dec1, _initProto$1;
+_dec$1 = instrument('TaskParserService.parse'), _dec1 = instrument('TaskParserService.buildJob');
+// Service
+class TaskParserService {
+    static{
+        ({ e: [_initProto$1] } = _(this, [
+            [
+                _dec$1,
+                2,
+                "parse"
+            ],
+            [
+                _dec1,
+                2,
+                "buildJob"
+            ]
+        ], []));
+    }
+    // Attributes
+    _logger = (_initProto$1(this), inject$(LOGGER).child(withLabel('task-parser')));
+    // Statics
+    static isTaskNode(node) {
+        return 'script' in node;
+    }
+    static _sequenceOperatorWarn = true;
+    // Methods
+    _lexer() {
+        return moo.states({
+            task: {
+                lparen: '(',
+                whitespace: /[ \t]+/,
+                script: {
+                    match: /[-_:a-zA-Z0-9]+/,
+                    push: 'operatorOrArgument'
+                },
+                string: [
+                    {
+                        match: /'(?:\\['\\]|[^\r\n'\\])+'/,
+                        push: 'operator',
+                        value: (x)=>x.slice(1, -1).replace(/\\(['\\])/g, '$1')
+                    },
+                    {
+                        match: /"(?:\\["\\]|[^\r\n"\\])+"/,
+                        push: 'operator',
+                        value: (x)=>x.slice(1, -1).replace(/\\(["\\])/g, '$1')
+                    }
+                ]
+            },
+            operator: {
+                rparen: ')',
+                whitespace: /[ \t]+/,
+                operator: {
+                    match: [
+                        '->',
+                        '&&',
+                        '//',
+                        '||'
+                    ],
+                    pop: 1
+                }
+            },
+            operatorOrArgument: {
+                rparen: ')',
+                whitespace: /[ \t]+/,
+                operator: {
+                    match: [
+                        '->',
+                        '&&',
+                        '//',
+                        '||'
+                    ],
+                    pop: 1
+                },
+                argument: [
+                    {
+                        match: /[-_:a-zA-Z0-9]+/
+                    },
+                    {
+                        match: /'(?:\\['\\]|[^\r\n'\\])+'/,
+                        value: (x)=>x.slice(1, -1).replace(/\\(['\\])/g, '$1')
+                    },
+                    {
+                        match: /"(?:\\["\\]|[^\r\n"\\])+"/,
+                        value: (x)=>x.slice(1, -1).replace(/\\(["\\])/g, '$1')
+                    }
+                ]
+            }
+        });
+    }
+    _nextNode(lexer, i = 0) {
+        let node = null;
+        for (const token of lexer){
+            // Ignore whitespaces
+            if (token.type === 'whitespace') {
+                continue;
+            }
+            // rparen = end of group
+            if (token.type === 'rparen') {
+                break;
+            }
+            // Handle argument
+            if (token.type === 'argument') {
+                if (!node) {
+                    throw new TaskSyntaxError(lexer.formatError(token, 'Unexpected argument'));
+                } else if (TaskParserService.isTaskNode(node)) {
+                    node.args.push(token.value);
+                } else {
+                    const lastTask = node.tasks[node.tasks.length - 1];
+                    if (!lastTask || !TaskParserService.isTaskNode(lastTask)) {
+                        throw new TaskSyntaxError(lexer.formatError(token, 'Unexpected argument'));
+                    } else {
+                        lastTask.args.push(token.value);
+                    }
+                }
+                continue;
+            }
+            // Handle operator
+            if (token.type === 'operator') {
+                const operator = token.value;
+                if (!node) {
+                    throw new TaskSyntaxError(lexer.formatError(token, 'Unexpected operator'));
+                } else if (TaskParserService.isTaskNode(node)) {
+                    node = {
+                        operator,
+                        tasks: [
+                            node
+                        ]
+                    };
+                    continue;
+                } else {
+                    if (node.operator !== operator) {
+                        node = {
+                            operator,
+                            tasks: [
+                                node
+                            ]
+                        };
+                    }
+                    continue;
+                }
+            }
+            // Build "child"
+            let child;
+            if (token.type === 'script') {
+                child = {
+                    script: token.value,
+                    args: []
+                };
+            } else if (token.type === 'string') {
+                const [script, ...args] = token.value.split(/ +/);
+                child = {
+                    script,
+                    args
+                };
+            } else if (token.type === 'lparen') {
+                const res = this._nextNode(lexer, i + 1);
+                if (!res) {
+                    throw new TaskSyntaxError(lexer.formatError(token, 'Empty group found'));
+                }
+                child = res;
+            } else {
+                throw new TaskSyntaxError(lexer.formatError(token, 'Unexpected token'));
+            }
+            if (!node) {
+                node = child;
+            } else if (TaskParserService.isTaskNode(node)) {
+                throw new TaskSyntaxError(lexer.formatError(token, 'Unexpected token, expected an operator'));
+            } else {
+                node.tasks.push(child);
+            }
+        }
+        return node;
+    }
+    parse(expr) {
+        const lexer = this._lexer().reset(expr);
+        const tree = {
+            roots: []
+        };
+        while(true){
+            const node = this._nextNode(lexer);
+            if (node) {
+                tree.roots.push(node);
+            } else {
+                break;
+            }
+        }
+        return tree;
+    }
+    *extractScripts(node) {
+        if ('roots' in node) {
+            for (const child of node.roots){
+                yield* this.extractScripts(child);
+            }
+        } else if (TaskParserService.isTaskNode(node)) {
+            yield node.script;
+        } else {
+            for (const child of node.tasks){
+                yield* this.extractScripts(child);
+            }
+        }
+    }
+    async buildJob(node, workspace, opts) {
+        if (TaskParserService.isTaskNode(node)) {
+            const job = await workspace.run(node.script, node.args, opts);
+            if (!job) {
+                throw new TaskExpressionError(`Workspace ${workspace.name} have no ${node.script} script`);
+            }
+            return job;
+        } else {
+            let flow;
+            if (node.operator === '//') {
+                flow = parallelFlow$({
+                    label: 'In parallel'
+                });
+            } else if (node.operator === '||') {
+                flow = fallbackFlow$({
+                    label: 'Fallbacks'
+                });
+            } else {
+                if (node.operator === '->' && TaskParserService._sequenceOperatorWarn) {
+                    this._logger.warn('Sequence operator -> is deprecated in favor of &&. It will be removed in a next major release.');
+                    TaskParserService._sequenceOperatorWarn = true;
+                }
+                flow = sequenceFlow$({
+                    label: 'In sequence'
+                });
+            }
+            for (const child of node.tasks){
+                flow.push(await this.buildJob(child, workspace, opts));
+            }
+            return flow;
+        }
+    }
+}
+
+function mutex$() {
+    const count$ = var$(0);
+    return {
+        async acquire () {
+            let cnt = count$.defer();
+            while(cnt > 0){
+                cnt = await waitFor$(count$);
+            }
+            count$.mutate(cnt + 1);
+        },
+        release () {
+            const cnt = count$.defer();
+            if (cnt > 0) {
+                count$.mutate(cnt - 1);
+            }
+        }
+    };
+}
+async function with$(lock, fn) {
     try {
-        await app.run(hideBin(process.argv));
-    } catch (err) {
-        if (err instanceof ExitException) {
-            process.exit(err.code);
+        await lock.acquire();
+        return await fn();
+    } finally{
+        lock.release();
+    }
+}
+
+function command$(workspace, cmd, args, opts = {}) {
+    const { superCommand, logger = inject$(LOGGER), ...rest } = opts;
+    // Apply super command
+    if (superCommand) {
+        if (typeof superCommand === 'string') {
+            args = [
+                cmd,
+                ...args
+            ];
+            cmd = superCommand;
+        } else if (superCommand.length) {
+            args = [
+                ...superCommand.slice(1),
+                cmd,
+                ...args
+            ];
+            cmd = superCommand[0];
+        }
+    }
+    // Prepare job
+    const job = spawn$(cmd, args, {
+        ...rest,
+        cwd: workspace.root,
+        env: {
+            FORCE_COLOR: '1',
+            ...rest.env
+        }
+    });
+    job.stdout.pipe(logStreamedLines(logger, LogLevel.info));
+    job.stderr.pipe(logStreamedLines(logger, LogLevel.info));
+    return job;
+}
+
+// Utils
+function capitalize(txt) {
+    return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+}
+function splitCommandLine(line) {
+    line = line.trim();
+    const parts = [];
+    let current_cote = '';
+    let last = 0;
+    for(let i = 1; i < line.length; ++i){
+        const c = line[i];
+        if (current_cote) {
+            if (c === current_cote) {
+                current_cote = '';
+            }
         } else {
-            console.error(await app.parser.getHelp());
-            if (err.message) {
-                const logger = container.get(Logger);
-                logger.error(err.message);
+            if ([
+                '"',
+                '\''
+            ].includes(c)) {
+                current_cote = c;
+            } else if (c === ' ') {
+                parts.push(line.slice(last, i));
+                last = i + 1;
+            }
+        }
+    }
+    parts.push(line.slice(last));
+    return parts;
+}
+
+async function runScript$(workspace, script, args, opts = {}) {
+    // Run script itself
+    const jobs = [
+        await planScript$(workspace, script, args, opts)
+    ];
+    if (!jobs[0]) {
+        throw new ScriptNotFound(`No script ${script} in ${workspace.name}`);
+    }
+    // Run hooks
+    if (opts.runHooks) {
+        jobs.unshift(await planScript$(workspace, `pre${script}`, [], opts));
+        jobs.push(await planScript$(workspace, `post${script}`, [], opts));
+    }
+    // Prepare workflow
+    const flow = pipe$(jobs, filter$((job)=>job !== null), collect$(sequenceFlow$({
+        label: script,
+        type: 'script'
+    })));
+    return {
+        ...flow,
+        script,
+        workspace
+    };
+}
+// Utils
+async function planScript$(workspace, script, args, opts) {
+    // Load script
+    const line = workspace?.getScript(script);
+    if (!line) {
+        return null;
+    }
+    // Parse script
+    const [command, ...commandArgs] = splitCommandLine(line);
+    if (!command) {
+        return null;
+    }
+    if (command === 'jill') {
+        const argv = commandArgs.map((arg)=>arg.replace(/^["'](.+)["']$/, '$1'));
+        const { PlannerService } = await import('./planner.service.js');
+        const plannerService = inject$(PlannerService);
+        const job = await plannerService.plan(argv, workspace.root);
+        if (job) {
+            return job;
+        }
+    }
+    // Run command
+    const pm = await workspace.project.packageManager();
+    return command$(workspace, command, [
+        ...commandArgs,
+        ...args
+    ], {
+        logger: opts.logger,
+        superCommand: pm === 'yarn' && command !== 'yarn' ? [
+            'yarn',
+            'exec'
+        ] : undefined
+    });
+}
+class ScriptNotFound extends ClientError {
+    name = 'ScriptNotFound';
+}
+
+// Utils
+async function* combine(...generators) {
+    for (const gen of generators){
+        yield* gen;
+    }
+}
+
+class Workspace {
+    manifest;
+    project;
+    // Attributes
+    _affectedCache = new Map();
+    _logger;
+    _git = inject$(GitService);
+    _root;
+    _jobs = new Map();
+    // Constructor
+    constructor(root, manifest, project){
+        this.manifest = manifest;
+        this.project = project;
+        this._root = root;
+        this._logger = inject$(LOGGER).child(withLabel(manifest.name));
+    }
+    // Methods
+    async _buildDependencies(job, opts) {
+        const generators = [];
+        switch(opts.buildDeps ?? 'all'){
+            case 'all':
+                generators.unshift(this.devDependencies());
+            // eslint-disable-next no-fallthrough
+            case 'prod':
+                generators.unshift(this.dependencies());
+        }
+        // Build deps
+        for await (const dep of combine(...generators)){
+            const build = await dep.build(opts);
+            if (build) {
+                job.dependsOn(build);
+            }
+        }
+    }
+    async *_loadDependencies(dependencies, kind) {
+        for (const [dep, range] of Object.entries(dependencies)){
+            const ws = await this.project.workspace(dep);
+            if (ws) {
+                if (ws._satisfies(this, range)) {
+                    yield ws;
+                } else {
+                    this._logger.warning(`ignoring ${kind} ${ws.reference} as it does not match requirement ${range}`);
+                }
+            }
+        }
+    }
+    async _isAffected(reference) {
+        const isAffected = await this._git.isAffected(reference, [
+            this.root
+        ], {
+            cwd: this.project.root,
+            logger: this._logger
+        });
+        if (isAffected) {
+            return true;
+        }
+        // Test dependencies
+        const proms = [];
+        for await (const dep of combine(this.dependencies(), this.devDependencies())){
+            proms.push(dep.isAffected(reference));
+        }
+        const results = await Promise.all(proms);
+        return results.some((r)=>r);
+    }
+    _satisfies(from, range) {
+        if (range.startsWith('file:')) {
+            return path.resolve(from.root, range.substring(5)) === this.root;
+        }
+        if (range.startsWith('workspace:')) {
+            range = range.substring(10);
+        }
+        return !this.version || satisfies(this.version, range);
+    }
+    async isAffected(reference) {
+        let isAffected = this._affectedCache.get(reference);
+        if (!isAffected) {
+            isAffected = this._isAffected(reference);
+            this._affectedCache.set(reference, isAffected);
+        }
+        return await isAffected;
+    }
+    async *dependencies() {
+        if (!this.manifest.dependencies) return;
+        for await (const ws of this._loadDependencies(this.manifest.dependencies, 'dependency')){
+            yield ws;
+        }
+    }
+    async *devDependencies() {
+        if (!this.manifest.devDependencies) return;
+        for await (const ws of this._loadDependencies(this.manifest.devDependencies, 'devDependency')){
+            yield ws;
+        }
+    }
+    async build(opts = {}) {
+        const script = opts.buildScript ?? 'build';
+        const job = await this.run(script, [], opts);
+        if (!job) {
+            this._logger.warning(`will not be built (no "${script}" script found)`);
+        }
+        return job;
+    }
+    async exec(command, args = [], opts = {}) {
+        const pm = await this.project.packageManager();
+        const job = command$(this, command, args, {
+            ...opts,
+            logger: this._logger.child(withLabel(`${this.name}$${command}`)),
+            superCommand: pm === 'yarn' ? [
+                'yarn',
+                'exec'
+            ] : undefined
+        });
+        await this._buildDependencies(job, opts);
+        return job;
+    }
+    getScript(script) {
+        const { scripts = {} } = this.manifest;
+        return scripts[script] || null;
+    }
+    async run(script, args = [], opts = {}) {
+        // Script not found
+        if (!this.getScript(script)) {
+            return null;
+        }
+        // Create task if it doesn't exist yet
+        let job = this._jobs.get(script);
+        if (!job) {
+            const config = await inject$(CONFIG, asyncScope$());
+            job = await runScript$(this, script, args, {
+                ...opts,
+                logger: this._logger.child(withLabel(`${this.name}#${script}`)),
+                runHooks: config.hooks
+            });
+            await this._buildDependencies(job, opts);
+            this._jobs.set(script, job);
+        }
+        return job;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            version: this.version,
+            root: this.root
+        };
+    }
+    // Properties
+    get name() {
+        return this.manifest.name;
+    }
+    get reference() {
+        return this.version ? `${this.name}@${this.version}` : this.name;
+    }
+    get root() {
+        return path.resolve(this.project.root, this._root);
+    }
+    get version() {
+        return this.manifest.version;
+    }
+}
+
+class Project {
+    // Attributes
+    _isFullyLoaded = false;
+    _lock = mutex$();
+    _mainWorkspace;
+    _packageManager;
+    _workspaceGlob;
+    _names = new Map();
+    _logger = inject$(LOGGER).child(withLabel('project'));
+    _root;
+    _scurry = inject$(PATH_SCURRY);
+    _workspaces = new Map();
+    // Constructor
+    constructor(root, opts = {}){
+        this._root = root;
+        if (opts.packageManager) {
+            this._logger.verbose`Forced use of ${opts.packageManager} in ${root}`;
+            this._packageManager = opts.packageManager;
+        }
+    }
+    // Methods
+    async _loadManifest(dir) {
+        const file = path.resolve(this.root, dir, 'package.json');
+        const relative = path.relative(this.root, path.dirname(file));
+        const logger = this._logger.child(withLabel(relative ? `project@${relative}` : 'project'));
+        logger.debug('loading package.json ...');
+        const data = await fs.promises.readFile(file, 'utf-8');
+        const mnf = JSON.parse(data);
+        normalize(mnf, (msg)=>logger.verbose(msg));
+        return mnf;
+    }
+    _loadWorkspace(dir) {
+        return with$(this._lock, async ()=>{
+            let wks = this._workspaces.get(dir);
+            if (!wks) {
+                const manifest = await this._loadManifest(dir);
+                wks = new Workspace(dir, manifest, this);
+                this._workspaces.set(dir, wks);
+                this._names.set(wks.name, wks);
+            }
+            return wks;
+        });
+    }
+    async currentWorkspace(cwd = inject$(CWD, asyncScope$())) {
+        let workspace = null;
+        cwd = path.resolve(cwd);
+        for await (const wks of this.workspaces()){
+            if (cwd.startsWith(wks.root)) {
+                workspace = wks;
+                if (wks.root !== this.root) return wks;
+            }
+        }
+        return workspace;
+    }
+    async mainWorkspace() {
+        if (!this._mainWorkspace) {
+            const manifest = await this._loadManifest('.');
+            this._mainWorkspace = new Workspace('.', manifest, this);
+            this._names.set(this._mainWorkspace.name, this._mainWorkspace);
+        }
+        return this._mainWorkspace;
+    }
+    async packageManager() {
+        if (!this._packageManager) {
+            this._logger.debug`searching lockfile in ${this.root}`;
+            const files = await this._scurry.readdir(this.root, {
+                withFileTypes: false
+            });
+            if (files.includes('yarn.lock')) {
+                this._logger.debug`detected yarn in ${this.root}`;
+                this._packageManager = 'yarn';
+            } else if (files.includes('package-lock.json')) {
+                this._logger.debug`detected npm in ${this.root}`;
+                this._packageManager = 'npm';
+            } else {
+                this._logger.debug`no package manager recognized in ${this.root}, defaults to npm`;
+                this._packageManager = 'npm';
+            }
+        }
+        return this._packageManager;
+    }
+    async workspace(name) {
+        // With current directory
+        if (!name) {
+            const dir = path.relative(this.root, inject$(CWD, asyncScope$()));
+            return this._loadWorkspace(dir);
+        }
+        // Try name index
+        const wks = this._names.get(name);
+        if (wks) {
+            return wks;
+        }
+        // Load workspaces
+        if (!this._isFullyLoaded) {
+            for await (const ws of this.workspaces()){
+                if (ws.name === name) {
+                    return ws;
+                }
+            }
+            this._isFullyLoaded = true;
+        }
+        return null;
+    }
+    async *workspaces() {
+        const main = await this.mainWorkspace();
+        yield main;
+        if (this._isFullyLoaded) {
+            for (const wks of this._names.values()){
+                if (wks.name !== main.name) yield wks;
+            }
+        } else {
+            // Load child workspaces
+            const patterns = main.manifest.workspaces ?? [];
+            this._scurry.chdir(this.root);
+            this._workspaceGlob ??= new Glob(patterns, {
+                scurry: this._scurry,
+                withFileTypes: true
+            });
+            for await (const dir of this._workspaceGlob){
+                try {
+                    // Check if dir is a directory
+                    if (dir.isDirectory()) {
+                        yield await this._loadWorkspace(dir.fullpath());
+                    }
+                } catch (error) {
+                    if (error.code === 'ENOENT') {
+                        continue;
+                    }
+                    throw error;
+                }
+            }
+            this._isFullyLoaded = true;
+        }
+    }
+    // Properties
+    get root() {
+        return path.resolve(this._root);
+    }
+}
+
+var _dec, _initProto;
+_dec = instrument();
+/**
+ * Helps detecting projects folders
+ */ class ProjectsRepository {
+    static{
+        ({ e: [_initProto] } = _(this, [
+            [
+                _dec,
+                2,
+                "searchProjectRoot"
+            ]
+        ], []));
+    }
+    // Attributes
+    _cache = (_initProto(this), new Map());
+    _logger = inject$(LOGGER).child(withLabel('projects'));
+    _scurry = inject$(PATH_SCURRY);
+    // Methods
+    async isProjectRoot(dir) {
+        this._logger.debug`testing ${dir}`;
+        const files = await this._scurry.readdir(dir, {
+            withFileTypes: false
+        });
+        return {
+            hasManifest: files.includes(MANIFEST),
+            hasLockFile: LOCK_FILES.some((lock)=>files.includes(lock))
+        };
+    }
+    async searchProjectRoot(directory) {
+        directory = path.resolve(directory);
+        // Test all ancestors
+        let foundManifest = false;
+        let projectRoot = directory;
+        let dir = directory;
+        let prev = dir;
+        do {
+            // Look for files
+            const { hasManifest, hasLockFile } = await this.isProjectRoot(dir);
+            if (hasManifest) {
+                projectRoot = dir;
+                foundManifest = true;
+            }
+            if (hasLockFile) {
+                break;
+            }
+            prev = dir;
+            dir = path.dirname(dir);
+        }while (prev !== dir);
+        // Log it
+        if (foundManifest) {
+            this._logger.verbose`project root found at ${projectRoot}`;
+        } else {
+            this._logger.verbose`project root not found, keeping ${projectRoot}`;
+        }
+        return projectRoot;
+    }
+    getProject(root, opts) {
+        let project = this._cache.get(root);
+        if (!project) {
+            project = new Project(root, opts);
+            this._cache.set(root, project);
+        }
+        return project;
+    }
+}
+// Constants
+const MANIFEST = 'package.json';
+const LOCK_FILES = [
+    'package-lock.json',
+    'yarn.lock'
+];
+
+/**
+ * Adds arguments to load a project.
+ */ function withProject(parser) {
+    return parser.option('project', {
+        alias: 'p',
+        type: 'string',
+        default: '',
+        defaultDescription: 'current working directory',
+        description: 'Project root directory',
+        normalize: true
+    }).option('package-manager', {
+        choices: [
+            'yarn',
+            'npm'
+        ],
+        type: 'string',
+        description: 'Force package manager'
+    }).middleware((args)=>startSpan({
+            name: 'project',
+            op: 'cli.middleware'
+        }, async ()=>{
+            const repository = inject$(ProjectsRepository);
+            const directory = path.resolve(inject$(CWD, asyncScope$()), args.project);
+            args.project = await repository.searchProjectRoot(directory);
+        }));
+}
+/**
+ * Loads a project, based on arguments.
+ */ function loadProject(args) {
+    const repository = inject$(ProjectsRepository);
+    return repository.getProject(args.project, {
+        packageManager: args.packageManager
+    });
+}
+
+function pipeline$() {
+    const steps = [];
+    return {
+        add (step) {
+            steps.push(step);
+            return this;
+        },
+        build () {
+            return (value)=>steps.reduce((val, step)=>step(val), value);
+        }
+    };
+}
+
+// Command
+const command$5 = {
+    command: 'each <expr>',
+    describe: 'Run a task expression in many workspace, after having built all theirs dependencies.',
+    builder: (parser)=>withProject(parser).positional('expr', {
+            type: 'string',
+            demandOption: true,
+            desc: 'Script or task expression'
+        }).option('affected', {
+            alias: 'a',
+            type: 'string',
+            coerce: (rev)=>rev === '' ? 'master' : rev,
+            group: 'Filters:',
+            desc: 'Print only affected workspaces towards given git revision. If no revision is given, it will check towards master. Replaces %name by workspace name.'
+        }).option('affected-rev-fallback', {
+            type: 'string',
+            default: 'master',
+            group: 'Filters:',
+            desc: 'Fallback revision, used if no revision matching the given format is found'
+        }).option('affected-rev-sort', {
+            type: 'string',
+            group: 'Filters:',
+            desc: 'Sort applied to git tag / git branch command'
+        }).option('allow-no-workspaces', {
+            type: 'boolean',
+            default: false,
+            desc: 'Allow no matching workspaces. Without it jill will exit with code 1 if no workspace matches'
+        }).option('build-script', {
+            default: 'build',
+            desc: 'Script to use to build dependencies'
+        }).option('deps-mode', {
+            alias: 'd',
+            choice: [
+                'all',
+                'prod',
+                'none'
+            ],
+            default: 'all',
+            desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
+        }).option('private', {
+            type: 'boolean',
+            group: 'Filters:',
+            describe: 'Print only private workspaces'
+        })// Config
+        .strict(false).parserConfiguration({
+            'unknown-options-as-args': true
+        }),
+    async prepare (args) {
+        // Extract expression
+        const expr = args._.map((arg)=>arg.toString());
+        if (expr[0] === 'each') {
+            expr.splice(0, 1);
+        }
+        expr.unshift(args.expr);
+        // Prepare filters
+        let filters = pipeline$();
+        if (args.private !== undefined) {
+            filters = filters.add(isPrivate$(args.private));
+        }
+        if (args.affected !== undefined) {
+            filters = filters.add(isAffected$({
+                format: args.affected,
+                fallback: args.affectedRevFallback,
+                sort: args.affectedRevSort
+            }));
+        }
+        // Parse task expression
+        const taskParser = inject$(TaskParserService);
+        const tree = taskParser.parse(expr.join(' '));
+        const scripts = Array.from(taskParser.extractScripts(tree));
+        // Load workspaces
+        const project = loadProject(args);
+        const workspaces = await waitFor$(pipe$(asyncIterator$(project.workspaces()), hasEveryScript$(scripts), filters.build(), collect$()));
+        workspaces.sort((a, b)=>a.name.localeCompare(b.name));
+        if (workspaces.length === 0) {
+            return;
+        }
+        // Prepare tasks
+        const flow = parallelFlow$({
+            label: '[hidden]'
+        });
+        for (const wks of workspaces){
+            flow.push(await taskParser.buildJob(tree.roots[0], wks, {
+                buildScript: args.buildScript,
+                buildDeps: args.depsMode
+            }));
+        }
+        return flow;
+    }
+};
+
+/**
+ * Adds arguments to load a workspace.
+ */ function withWorkspace(parser) {
+    return withProject(parser).option('workspace', {
+        alias: 'w',
+        type: 'string',
+        desc: 'Workspace to use'
+    });
+}
+/**
+ * Loads a workspace, based on arguments.
+ */ async function loadWorkspace(args) {
+    const logger = inject$(LOGGER);
+    const project = loadProject(args);
+    let workspace;
+    if (args.workspace) {
+        logger.debug(`loading workspace "${args.workspace}"`);
+        workspace = await project.workspace(args.workspace);
+    } else if (inject$(CWD, asyncScope$()).startsWith(project.root)) {
+        logger.debug('loading workspace containing current directory');
+        workspace = await project.currentWorkspace(inject$(CWD, asyncScope$()));
+    } else {
+        logger.debug('loading main workspace');
+        workspace = await project.mainWorkspace();
+    }
+    if (!workspace) {
+        throw new WorkspaceNotFound(args.workspace || '.');
+    }
+    return workspace;
+}
+class WorkspaceNotFound extends ClientError {
+    name = 'WorkspaceNotFound';
+    constructor(workspace){
+        super(`Workspace "${workspace}" not found`);
+    }
+}
+
+// Command
+const command$4 = {
+    command: 'exec <command>',
+    aliases: [
+        '$0'
+    ],
+    describe: 'Run command inside workspace, after all its dependencies has been built.',
+    builder: (args)=>withWorkspace(args).positional('command', {
+            type: 'string',
+            demandOption: true
+        }).option('build-script', {
+            default: 'build',
+            desc: 'Script to use to build dependencies'
+        }).option('deps-mode', {
+            alias: 'd',
+            choice: [
+                'all',
+                'prod',
+                'none'
+            ],
+            default: 'all',
+            desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
+        })// Documentation
+        .example('jill exec eslint', '').example('jill exec eslint --env-info', 'Unknown arguments are passed down to command. Here it will run "eslint --env-info"').example('jill exec eslint -- -v', 'You can use -- to stop argument parsing. Here it will run "eslint -v"')// Config
+        .strict(false).parserConfiguration({
+            'unknown-options-as-args': true
+        }),
+    async prepare (args) {
+        const workspace = await loadWorkspace(args);
+        // Extract arguments
+        const rest = args._.map((arg)=>arg.toString());
+        if (rest[0] === 'exec') {
+            rest.splice(0, 1);
+        }
+        // Run script in workspace
+        return await workspace.exec(args.command, rest, {
+            buildScript: args.buildScript,
+            buildDeps: args.depsMode
+        });
+    },
+    async execute (args, arg) {
+        const job = arg;
+        if (job.dependencies().length > 0) {
+            const dependencies = pipe$(job.dependencies(), collect$(parallelFlow$({
+                label: 'build dependencies'
+            })));
+            // Run dependencies first with spinners
+            const { JobCommandExecuteInk } = await traceImport('JobCommandExecuteInk', ()=>import('./job-command-execute.ink.js'));
+            await JobCommandExecuteInk({
+                job: dependencies,
+                verbose: [
+                    'verbose',
+                    'debug'
+                ].includes(args.verbose)
+            });
+            if (dependencies.state() !== WorkloadState.Succeeded) {
+                return;
             }
-            process.exit(1);
+        } else {
+            const logger = inject$(LOGGER);
+            logger.verbose('No dependency to build');
         }
+        await startSpan({
+            op: 'subprocess',
+            name: [
+                job.cmd,
+                ...job.args
+            ].join(' ')
+        }, async ()=>{
+            const child = spawn(job.cmd, job.args, {
+                stdio: 'inherit',
+                cwd: job.cwd,
+                env: {
+                    ...process$1.env,
+                    ...job.env
+                },
+                shell: true,
+                windowsHide: true
+            });
+            process$1.exitCode = await new Promise((resolve)=>{
+                child.on('close', (code)=>{
+                    resolve(code ?? 0);
+                });
+            });
+        });
+    }
+};
+
+// Utils
+function printJson(data, stream = process.stdout) {
+    if (stream.isTTY) {
+        stream.write(JSON.stringify(data, null, 2));
+    } else {
+        stream.write(JSON.stringify(data));
     }
-})();
+}
+
+// Command
+const command$3 = {
+    command: 'list',
+    aliases: [
+        'ls'
+    ],
+    describe: 'List project workspaces',
+    builder: (parser)=>withProject(parser).option('affected', {
+            alias: 'a',
+            type: 'string',
+            coerce: (rev)=>rev === '' ? 'master' : rev,
+            group: 'Filters:',
+            desc: `Print only affected workspaces towards given git revision. If no revision is given, it will check towards master. Replaces ${chalk.bold('%name')} by workspace name.`
+        }).option('affected-rev-fallback', {
+            type: 'string',
+            default: 'master',
+            group: 'Filters:',
+            desc: 'Fallback revision, used if no revision matching the given format is found'
+        }).option('affected-rev-sort', {
+            type: 'string',
+            group: 'Filters:',
+            desc: 'Sort applied to git tag / git branch command'
+        }).option('attribute', {
+            alias: [
+                'attr',
+                'attrs'
+            ],
+            type: 'array',
+            choices: [
+                'name',
+                'version',
+                'root',
+                'slug'
+            ],
+            group: 'Format:',
+            default: [],
+            description: 'Select printed attributes',
+            defaultDescription: '"name" only'
+        }).option('headers', {
+            type: 'boolean',
+            group: 'Format:',
+            default: false,
+            desc: 'Prints columns headers'
+        }).option('long', {
+            alias: 'l',
+            type: 'boolean',
+            group: 'Format:',
+            default: false,
+            desc: 'Prints name, version and root of all workspaces'
+        }).option('json', {
+            type: 'boolean',
+            group: 'Format:',
+            default: false,
+            desc: 'Prints data as a JSON array'
+        }).option('private', {
+            type: 'boolean',
+            group: 'Filters:',
+            describe: 'Print only private workspaces'
+        }).option('sort-by', {
+            alias: 's',
+            type: 'array',
+            choices: [
+                'name',
+                'version',
+                'root',
+                'slug'
+            ],
+            group: 'Sort:',
+            default: [],
+            description: 'Sort output by given attribute',
+            defaultDescription: 'first attribute'
+        }).option('sort-order', {
+            alias: [
+                'o',
+                'order'
+            ],
+            type: 'string',
+            choices: [
+                'asc',
+                'desc'
+            ],
+            default: 'asc',
+            group: 'Sort:',
+            desc: 'Sort order'
+        }).option('with-script', {
+            type: 'array',
+            string: true,
+            group: 'Filters:',
+            desc: 'Print only workspaces having the given script'
+        }).middleware((argv)=>{
+            // Compute attributes
+            if (!argv.attribute.length) {
+                if (argv.json) {
+                    argv.attrs = argv.attr = argv.attribute = [
+                        'name',
+                        'version',
+                        'slug',
+                        'root'
+                    ];
+                } else if (argv.long) {
+                    argv.attrs = argv.attr = argv.attribute = [
+                        'name',
+                        'version',
+                        'root'
+                    ];
+                } else if (argv.sortBy?.length) {
+                    argv.attrs = argv.attr = argv.attribute = argv.sortBy;
+                } else {
+                    argv.attrs = argv.attr = argv.attribute = [
+                        'name'
+                    ];
+                }
+            }
+        }, true).check((argv)=>{
+            if (argv.attribute.length > 0 && argv['sort-by']?.length) {
+                const miss = argv['sort-by'].filter((attr)=>!argv.attribute.includes(attr));
+                if (miss.length > 0) {
+                    throw new ClientError(`Cannot sort by non printed attributes. Missing ${miss.join(', ')}.`);
+                }
+            }
+            if (!argv['sort-by']?.length && argv.attribute.length > 0) {
+                argv['sort-by'] = argv.sortBy = argv.s = [
+                    argv.attribute[0]
+                ];
+            }
+            return true;
+        }),
+    async handler (args) {
+        // Prepare filters
+        let filters = pipeline$();
+        if (args.private !== undefined) {
+            filters = filters.add(isPrivate$(args.private));
+        }
+        if (args.withScript) {
+            filters = filters.add(hasSomeScript$(args.withScript));
+        }
+        if (args.affected !== undefined) {
+            filters = filters.add(isAffected$({
+                format: args.affected,
+                fallback: args.affectedRevFallback,
+                sort: args.affectedRevSort
+            }));
+        }
+        // Load workspaces
+        const project = loadProject(args);
+        const workspaces = await waitFor$(pipe$(asyncIterator$(project.workspaces()), filters.build(), map$(buildExtractor(args)), collect$()));
+        if (args.sortBy.length > 0) {
+            workspaces.sort(buildComparator(args));
+        }
+        if (args.json) {
+            printJson(workspaces);
+        } else if (workspaces.length > 0) {
+            for (const data of workspaces){
+                if (data.root) {
+                    data.root = path.relative(process.cwd(), data.root) || '.';
+                }
+            }
+            const { default: ListInk } = await traceImport('ListInk', ()=>import('./list.ink.js'));
+            await ListInk({
+                attributes: args.attribute,
+                headers: args.headers,
+                workspaces
+            });
+        }
+    }
+};
+const EXTRACTORS = {
+    name: (wks)=>wks.name,
+    version: (wks, json)=>wks.manifest.version || (json ? undefined : chalk.grey('unset')),
+    root: (wks)=>wks.root,
+    slug: (wks)=>slugify(wks.name)
+};
+const COMPARATORS = {
+    name: (a = '', b = '')=>a.localeCompare(b),
+    version: (a, b)=>compare(parse(a) ?? '0.0.0', parse(b) ?? '0.0.0'),
+    root: (a = '', b = '')=>a.localeCompare(b),
+    slug: (a = '', b = '')=>a.localeCompare(b)
+};
+function buildExtractor(args) {
+    return (wks)=>{
+        const data = {};
+        for (const attr of args.attribute){
+            data[attr] = EXTRACTORS[attr](wks, args.json);
+        }
+        return data;
+    };
+}
+function buildComparator(args) {
+    const factor = args.sortOrder === 'asc' ? 1 : -1;
+    return (a, b)=>{
+        for (const attr of args.sortBy){
+            const diff = COMPARATORS[attr](a[attr], b[attr]);
+            if (diff !== 0) {
+                return diff * factor;
+            }
+        }
+        return 0;
+    };
+}
+
+// Command
+const command$2 = {
+    command: 'run <expr>',
+    describe: 'Run a task expression in a workspace, after having built all its dependencies.',
+    builder: (parser)=>withWorkspace(parser).positional('expr', {
+            type: 'string',
+            demandOption: true,
+            desc: 'Script or task expression'
+        }).option('build-script', {
+            default: 'build',
+            desc: 'Script to use to build dependencies'
+        }).option('deps-mode', {
+            alias: 'd',
+            choice: [
+                'all',
+                'prod',
+                'none'
+            ],
+            default: 'all',
+            desc: 'Dependency selection mode:\n' + ' - all = dependencies AND devDependencies\n' + ' - prod = dependencies\n' + ' - none = nothing'
+        })// Config
+        .strict(false).parserConfiguration({
+            'unknown-options-as-args': true
+        }),
+    async prepare (args) {
+        const workspace = await loadWorkspace(args);
+        // Extract expression
+        const expr = args._.map((arg)=>arg.toString());
+        if (expr[0] === 'run') {
+            expr.splice(0, 1);
+        }
+        expr.unshift(args.expr);
+        // Parse task expression
+        const taskParser = inject$(TaskParserService);
+        const tree = taskParser.parse(expr.join(' '));
+        return await taskParser.buildJob(tree.roots[0], workspace, {
+            buildScript: args.buildScript,
+            buildDeps: args.depsMode
+        });
+    }
+};
+
+// Command
+const command$1 = {
+    command: 'tree',
+    describe: 'Print workspace dependency tree',
+    builder: withWorkspace,
+    async handler (args) {
+        const workspace = await loadWorkspace(args);
+        const { default: TreeInk } = await traceImport('TreeInk', ()=>import('./tree.ink.js'));
+        await TreeInk({
+            workspace
+        });
+    }
+};
+
+var version = "3.0.0-alpha.10";
+
+// Utils
+function dynamicImport(filepath) {
+    return import(/* webpackIgnore: true */ process.platform === 'win32' ? `file://${filepath}` : filepath);
+}
+
+const ConfigExplorer = token$('ConfigExplorer', ()=>cosmiconfig('jill', {
+        searchStrategy: 'global',
+        loaders: {
+            '.cjs': (filepath)=>dynamicImport(filepath).then((mod)=>mod.default),
+            '.js': (filepath)=>dynamicImport(filepath).then((mod)=>mod.default),
+            '.json': defaultLoaders['.json'],
+            '.yaml': defaultLoaders['.yaml'],
+            '.yml': defaultLoaders['.yml'],
+            noExt: defaultLoaders.noExt
+        }
+    }));
+
+var $schema = "http://json-schema.org/draft-07/schema";
+var type = "object";
+var additionalProperties = false;
+var properties = {
+	hooks: {
+		type: "boolean",
+		"default": true,
+		description: "Instructs jill to run hook scripts."
+	},
+	jobs: {
+		type: "number",
+		"default": 0,
+		description: "Number of allowed parallel tasks, defaults to CPU number."
+	}
+};
+var schema = {
+	$schema: $schema,
+	type: type,
+	additionalProperties: additionalProperties,
+	properties: properties
+};
+
+/**
+ * Loads and make configuration accessible
+ */ class ConfigService {
+    // Attributes
+    _filepath;
+    _config = var$();
+    _logger = inject$(LOGGER).child(withLabel('config'));
+    _explorer = inject$(ConfigExplorer);
+    // Constructor
+    constructor(state = {}){
+        if (state.filepath) {
+            this._filepath = state.filepath;
+        }
+        if (state.config) {
+            this._config.mutate(state.config);
+        }
+    }
+    // Methods
+    _validateConfig(config) {
+        // Validate config
+        const ajv = new Ajv({
+            allErrors: true,
+            useDefaults: true,
+            logger: this._logger.child(withLabel('ajv')),
+            strict: process$1.env.NODE_ENV === 'development' ? 'log' : true
+        });
+        const validator = ajv.compile(schema);
+        if (!validator(config)) {
+            const errors = ajv.errorsText(validator.errors, {
+                separator: '\n- ',
+                dataVar: 'config'
+            });
+            this._logger.error(`errors in config file:\n- ${errors}`);
+            throw new Error('Error in config file');
+        }
+        // Correct jobs value
+        if (config.jobs <= 0) {
+            Object.assign(config, {
+                jobs: Math.max(os.availableParallelism() - 1, 1)
+            });
+        }
+        this._logger.debug`loaded config:\n${qjson(config, {
+            pretty: true
+        })}`;
+        return config;
+    }
+    async searchConfig() {
+        const loaded = await this._explorer.search(inject$(CWD, asyncScope$()));
+        if (loaded) {
+            this._logger.verbose`loaded file ${loaded.filepath}`;
+            this._filepath = loaded.filepath;
+        }
+        const config = this._validateConfig(loaded?.config ?? {});
+        this._config.mutate(config);
+    }
+    async loadConfig(filepath) {
+        const loaded = await this._explorer.load(filepath);
+        if (loaded) {
+            this._logger.verbose`loaded file ${loaded.filepath}`;
+            this._filepath = loaded.filepath;
+        }
+        const config = this._validateConfig(loaded?.config ?? {});
+        this._config.mutate(config);
+    }
+    // Attributes
+    get baseDir() {
+        return this._filepath ? path.dirname(this._filepath) : inject$(CWD, asyncScope$());
+    }
+    get config$() {
+        return this._config;
+    }
+    get config() {
+        return this._config.defer();
+    }
+    get state() {
+        return {
+            filepath: this._filepath,
+            config: this.config
+        };
+    }
+}
+
+var config_service = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ConfigService: ConfigService
+});
+
+/**
+ * Adds configuration arguments and loading.
+ */ function withConfig(parser) {
+    return parser.option('config-file', {
+        alias: 'c',
+        type: 'string',
+        description: 'Configuration file'
+    }).middleware((args)=>startSpan({
+            name: 'config',
+            op: 'cli.middleware'
+        }, async ()=>{
+            const configService = inject$(ConfigService, asyncScope$());
+            if (args.configFile) {
+                await configService.loadConfig(args.configFile);
+            } else {
+                await configService.searchConfig();
+            }
+        }));
+}
+
+const LEVEL_COLORS = {
+    [LogLevel.debug]: 'grey',
+    [LogLevel.verbose]: 'blue',
+    [LogLevel.info]: 'reset',
+    [LogLevel.warning]: 'yellow',
+    [LogLevel.error]: 'red'
+};
+const logColor = defineQuickFormat((level)=>LEVEL_COLORS[level])(qprop('level'));
+const logFormat = qwrap(chalkTemplateStderr).fun`#?:${qprop('label')}{grey [${q$}]} ?#{${logColor} ${qprop('message')} {grey +${qLogDelay(qarg())}}#?:${qerror(qprop('error'))}${os.EOL}${q$}?#}`;
+
+/**
+ * Adds logger related arguments.
+ */ function withLogger(parser) {
+    return parser.option('verbose', {
+        alias: 'v',
+        default: 'info',
+        type: 'count',
+        description: 'Set verbosity level',
+        coerce: (cnt)=>VERBOSITY_LEVEL[Math.min(cnt, 2)]
+    }).middleware((args)=>startSpan({
+            name: 'logger',
+            op: 'cli.middleware'
+        }, ()=>{
+            const logLevel = args.verbose ? LogLevel[args.verbose] : LogLevel.info;
+            const logGateway = inject$(LogGateway);
+            flow$(inject$(LOGGER), filter$((log)=>log.level >= logLevel), logDelay$(), logGateway);
+            logGateway.connect('console', toStderr(logFormat));
+        }));
+}
+// Utils
+const VERBOSITY_LEVEL = {
+    1: 'verbose',
+    2: 'debug'
+};
+
+// Utils
+function cliParser() {
+    return pipe$(yargs().scriptName('jill').version(version).demandCommand().recommendCommands(), withLogger, withConfig);
+}
+
+function commandName(module) {
+    if (!module.command) {
+        return '[unknown]';
+    }
+    if (typeof module.command === 'string') {
+        return module.command;
+    }
+    return module.command[0];
+}
+
+function command(module) {
+    const name = commandName(module);
+    const handler = trace(module.handler, {
+        name: commandName(module),
+        op: 'cli.handler'
+    });
+    return (parser)=>parser.command({
+            ...module,
+            async handler (args) {
+                const activeSpan = getActiveSpan();
+                if (activeSpan) {
+                    updateSpanName(getRootSpan(activeSpan), `jill ${name}`);
+                }
+                await handler(args);
+            }
+        });
+}
+
+function jobCommandPlan(module, job$) {
+    if ('prepare' in module) {
+        const prepare = trace(module.prepare, {
+            name: commandName(module),
+            op: 'cli.prepare'
+        });
+        return command({
+            ...module,
+            builder (base) {
+                const parser = withPlanMode(base);
+                if (module.builder) {
+                    return module.builder(parser);
+                } else {
+                    return parser;
+                }
+            },
+            async handler (args) {
+                job$.mutate(await prepare(args) ?? null);
+            }
+        });
+    } else {
+        return command({
+            ...module,
+            handler: ()=>undefined
+        });
+    }
+}
+// Utils
+function withPlanMode(parser) {
+    return parser.option('plan', {
+        type: 'boolean',
+        default: false,
+        describe: 'Only prints tasks to be run'
+    }).option('plan-mode', {
+        type: 'string',
+        desc: 'Plan output mode',
+        choices: [
+            'json',
+            'list'
+        ],
+        default: 'list'
+    });
+}
+
+function jobCommandExecute(module) {
+    const prepare = trace(module.prepare, {
+        name: commandName(module),
+        op: 'cli.prepare'
+    });
+    const execute = module.execute && trace(module.execute, {
+        name: commandName(module),
+        op: 'cli.execute'
+    });
+    return command({
+        ...module,
+        builder (base) {
+            const parser = withPlanMode(base);
+            if (module.builder) {
+                return module.builder(parser);
+            } else {
+                return parser;
+            }
+        },
+        async handler (args) {
+            const job = await prepare(args) ?? null;
+            if (!job) {
+                const logger = inject$(LOGGER);
+                logger.warning('No task found');
+                process$1.exitCode = 1;
+                return;
+            }
+            if (args.plan) {
+                const { jobPlan } = await traceImport('printPlan', ()=>import('./job-plan.js'));
+                jobPlan(job);
+            } else {
+                if (execute) {
+                    await execute(args, job);
+                } else {
+                    const { JobCommandExecuteInk } = await traceImport('JobCommandExecuteInk', ()=>import('./job-command-execute.ink.js'));
+                    await JobCommandExecuteInk({
+                        job,
+                        verbose: [
+                            'verbose',
+                            'debug'
+                        ].includes(args.verbose)
+                    });
+                }
+            }
+        }
+    });
+}
+
+// Bootstrap
+const argv = hideBin(process$1.argv);
+const parser = pipe$(cliParser(), jobCommandExecute(command$5), jobCommandExecute(command$4), command(command$3), jobCommandExecute(command$2), command(command$1));
+void startSpan({
+    name: 'jill',
+    op: 'cli.main',
+    startTime: 0,
+    attributes: {
+        'cli.argv': argv
+    }
+}, async ()=>{
+    try {
+        startInactiveSpan({
+            name: 'bootstrap',
+            op: 'cli.bootstrap',
+            startTime: 0
+        }).end();
+        return await parser.wrap(parser.terminalWidth()).fail((msg, err)=>{
+            const logger = inject$(LOGGER);
+            if (msg) {
+                logger.error(msg);
+            } else if (err instanceof ClientError) {
+                logger.error(err.message);
+            } else {
+                captureException(err, {
+                    tags: {
+                        handled: false
+                    }
+                });
+                logger.error(err.message);
+            }
+            process$1.exitCode = 1;
+        }).parseAsync(argv);
+    } catch  {
+    // Already handled
+    }
+});
+
+export { CWD as C, LOGGER as L, SCHEDULER as S, ConfigService as a, cliParser as b, capitalize as c, command$5 as d, command$4 as e, command$3 as f, command$2 as g, command$1 as h, instrument as i, jobCommandPlan as j, logFormat as l };
 //# sourceMappingURL=main.js.map