@jujulego/jill 3.0.0-alpha.1 → 3.0.0-alpha.3

package/dist/parser.js

@@ -0,0 +1,2104 @@
+;{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]="870e33b2-51a5-4b3d-aff5-43027ce19814",e._sentryDebugIdIdentifier="sentry-dbid-870e33b2-51a5-4b3d-aff5-43027ce19814");})();}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.3"};}catch(e){}}();import { TaskManager, plan, SpawnTask, GroupTask, TaskSet, ParallelGroup, FallbackGroup, SequenceGroup } from '@jujulego/tasks';
+import { token$, inject$, asyncScope$ } from '@kyrielle/injector';
+import { pipe$, waitFor$, filter$, observable$, off$, once$, map$, collect$, asyncIterator$, var$, flow$ } from 'kyrielle';
+import { logger$, withTimestamp, withLabel, qLogDelay, LogLevel, LogGateway, logDelay$, toStderr } from '@kyrielle/logger';
+import { startSpan, getActiveSpan, updateSpanName, getRootSpan, startInactiveSpan } from '@sentry/node';
+import path from 'node:path';
+import cp from 'node:child_process';
+import process$1 from 'node:process';
+import chalk from 'chalk';
+import { satisfies, compare, parse } from 'semver';
+import slugify from 'slugify';
+import yargs from 'yargs';
+import fs from 'node:fs';
+import { PathScurry } from 'path-scurry';
+import { _ } from '@swc/helpers/_/_apply_decs_2203_r';
+import { Glob } from 'glob';
+import normalize from 'normalize-package-data';
+import moo from 'moo';
+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';
+
+var version = "3.0.0-alpha.3";
+
+function trace(fun, opts) {
+    const name = typeof opts === 'string' ? opts : opts.name;
+    const use = typeof opts === 'object' ? opts.use : (_, r)=>r;
+    return function(...args) {
+        return pipe$(startSpan({
+            name
+        }, ()=>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 traceAsyncGenerator(name, generator) {
+    const instrumented = {
+        ...generator,
+        next: async ()=>startSpan({
+                name,
+                op: 'iterator.next'
+            }, ()=>generator.next()),
+        [Symbol.asyncIterator]: ()=>instrumented
+    };
+    return instrumented;
+}
+function traceLoad(name, loader) {
+    return startSpan({
+        name: `load ${name}`,
+        op: 'import'
+    }, loader);
+}
+
+function command$5(module) {
+    const name = getCommandName(module);
+    const handler = trace(module.handler, 'cli.handler');
+    return (parser)=>parser.command({
+            ...module,
+            async handler (args) {
+                const activeSpan = getActiveSpan();
+                if (activeSpan) {
+                    updateSpanName(getRootSpan(activeSpan), `jill ${name}`);
+                }
+                await handler(args);
+            }
+        });
+}
+function getCommandName(module) {
+    if (!module.command) {
+        return '[unknown]';
+    }
+    if (typeof module.command === 'string') {
+        return module.command;
+    }
+    return module.command[0];
+}
+
+// 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 TASK_MANAGER = token$('TaskManager', async ()=>{
+    const manager = new TaskManager({
+        jobs: (await inject$(CONFIG, asyncScope$())).jobs,
+        logger: inject$(LOGGER)
+    });
+    let rootSpan = getActiveSpan();
+    if (rootSpan) rootSpan = getRootSpan(rootSpan);
+    const spans = new Map();
+    manager.events$.on('added', (task)=>{
+        // Main span
+        const span = startInactiveSpan({
+            name: task.name,
+            parentSpan: (task.group && spans.get(task.group.id)) ?? rootSpan,
+            op: 'task'
+        });
+        task.events$.on('completed', ({ status })=>{
+            span.setStatus({
+                code: status === 'done' ? 1 : 2
+            });
+            span.end();
+        });
+        spans.set(task.id, span);
+        // Status spans
+        let statusSpan = startInactiveSpan({
+            name: task.status,
+            parentSpan: span,
+            op: 'task.status'
+        });
+        task.events$.on('status', ({ status })=>{
+            statusSpan.end();
+            if (!task.completed) {
+                statusSpan = startInactiveSpan({
+                    name: status,
+                    parentSpan: span,
+                    op: 'task.status'
+                });
+            }
+        });
+    });
+    return manager;
+});
+
+// Utils
+function printJson(data, stream = process.stdout) {
+    if (stream.isTTY) {
+        stream.write(JSON.stringify(data, null, 2));
+    } else {
+        stream.write(JSON.stringify(data));
+    }
+}
+
+// Utils
+function executeCommand(module) {
+    const prepare = trace(module.prepare, 'cli.prepare');
+    const execute = module.execute && trace(module.execute, 'cli.execute');
+    return command$5({
+        ...module,
+        builder (base) {
+            const parser = withPlanMode(base);
+            if (module.builder) {
+                return module.builder(parser);
+            } else {
+                return parser;
+            }
+        },
+        async handler (args) {
+            const tasks = await prepare(args);
+            if (args.plan) {
+                if (args.planMode === 'json') {
+                    printJson(Array.from(plan(tasks)));
+                } else {
+                    const { default: TaskPlanInk } = await traceLoad('TaskPlanInk', ()=>import('./task-plan.ink.js'));
+                    await TaskPlanInk({
+                        tasks
+                    });
+                }
+            } else {
+                if (execute) {
+                    await execute(args, tasks);
+                } else if (tasks.tasks.length > 0) {
+                    const { default: TaskExecInk } = await traceLoad('TaskExecInk', ()=>import('./task-exec.ink.js'));
+                    await TaskExecInk({
+                        tasks,
+                        verbose: [
+                            'verbose',
+                            'debug'
+                        ].includes(args.verbose)
+                    });
+                } else {
+                    const logger = inject$(LOGGER);
+                    logger.warning('No task found');
+                    process$1.exitCode = 1;
+                }
+            }
+        }
+    });
+}
+function planCommand(module, tasks$) {
+    if ('prepare' in module) {
+        const prepare = trace(module.prepare, 'cli.prepare');
+        return command$5({
+            ...module,
+            builder (base) {
+                const parser = withPlanMode(base);
+                if (module.builder) {
+                    return module.builder(parser);
+                } else {
+                    return parser;
+                }
+            },
+            async handler (args) {
+                tasks$.mutate(await prepare(args));
+            }
+        });
+    } else {
+        return command$5({
+            ...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'
+    });
+}
+
+// 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);
+    });
+}
+
+// Utils
+async function* combine(...generators) {
+    for (const gen of generators){
+        yield* gen;
+    }
+}
+function streamLines$(task, stream = 'stdout') {
+    return observable$((observer, signal)=>{
+        const off = off$();
+        let current = '';
+        // End
+        off.add(once$(task.events$, 'completed', ()=>{
+            if (current) observer.next(current);
+            observer.complete();
+            off.unsubscribe();
+        }));
+        // Abort
+        signal.addEventListener('abort', ()=>off.unsubscribe(), {
+            once: true
+        });
+        // Steam
+        off.add(task.events$.on(`stream.${stream}`, (chunk)=>{
+            const data = current + chunk.data.toString('utf-8');
+            const lines = data.split(/\r?\n/);
+            current = lines.pop() ?? '';
+            for (const line of lines){
+                observer.next(line);
+            }
+        }));
+    });
+}
+
+var _dec$4, _dec1$3, _dec2$1, _initProto$4;
+_dec$4 = instrument('GitService.isAffected'), _dec1$3 = instrument('GitService.listBranches'), _dec2$1 = instrument('GitService.listTags');
+class GitService {
+    static{
+        ({ e: [_initProto$4] } = _(this, [
+            [
+                _dec$4,
+                2,
+                "isAffected"
+            ],
+            [
+                _dec1$3,
+                2,
+                "listBranches"
+            ],
+            [
+                _dec2$1,
+                2,
+                "listTags"
+            ]
+        ], []));
+    }
+    // Attributes
+    _manager = (_initProto$4(this), inject$(TASK_MANAGER));
+    _logger = inject$(LOGGER);
+    // Methods
+    /**
+   * Runs a git command inside a SpawnTask
+   *
+   * @param cmd
+   * @param args
+   * @param options
+   */ async command(cmd, args, options = {}) {
+        const opts = {
+            logger: this._logger,
+            ...options
+        };
+        // Create task
+        const task = new SpawnTask('git', [
+            cmd,
+            ...args
+        ], {
+            command: cmd,
+            hidden: true
+        }, opts);
+        task.events$.on('stream', ({ data })=>opts.logger.debug(data.toString('utf-8')));
+        (await this._manager).add(task);
+        return task;
+    }
+    /**
+   * Runs git branch
+   *
+   * @param args
+   * @param options
+   */ branch(args, options) {
+        return this.command('branch', args, options);
+    }
+    /**
+   * Runs git diff
+   *
+   * @param args
+   * @param options
+   */ diff(args, options) {
+        return this.command('diff', args, options);
+    }
+    /**
+   * Runs git tag
+   *
+   * @param args
+   * @param options
+   */ tag(args, options) {
+        return this.command('tag', args, options);
+    }
+    /**
+   * Uses git diff to detect if given files have been affected since given reference
+   *
+   * @param reference
+   * @param files
+   * @param opts
+   */ async isAffected(reference, files = [], opts) {
+        const task = await this.diff([
+            '--quiet',
+            reference,
+            '--',
+            ...files
+        ], opts);
+        return new Promise((resolve, reject)=>{
+            once$(task.events$, 'status.done', ()=>resolve(false));
+            once$(task.events$, 'status.failed', ()=>{
+                if (task.exitCode) {
+                    resolve(true);
+                } else {
+                    reject(new Error(`Task ${task.name} failed`));
+                }
+            });
+        });
+    }
+    /**
+   * List git branches
+   *
+   * @param args
+   * @param opts
+   */ async listBranches(args = [], opts) {
+        const task = await this.branch([
+            '-l',
+            ...args
+        ], opts);
+        return waitFor$(pipe$(streamLines$(task), map$((line)=>line.replace(/^[ *] /, '')), collect$()));
+    }
+    /**
+   * List git tags
+   *
+   * @param args
+   * @param opts
+   */ async listTags(args = [], opts) {
+        const task = await this.tag([
+            '-l',
+            ...args
+        ], opts);
+        return waitFor$(pipe$(streamLines$(task), collect$()));
+    }
+}
+
+// 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);
+}
+
+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 lock.acquire();
+        return await fn();
+    } finally{
+        lock.release();
+    }
+}
+
+// Class
+class CommandTask extends SpawnTask {
+    workspace;
+    // Constructor
+    constructor(workspace, command, args, opts = {}){
+        let cmd = command;
+        if (opts.superCommand) {
+            if (typeof opts.superCommand === 'string') {
+                opts.superCommand = [
+                    opts.superCommand
+                ];
+            }
+            if (opts.superCommand.length > 0) {
+                cmd = opts.superCommand[0];
+                args = [
+                    ...opts.superCommand.slice(1),
+                    command,
+                    ...args
+                ];
+            }
+        }
+        super(cmd, args, {
+            workspace,
+            command
+        }, {
+            ...opts,
+            cwd: workspace.root,
+            env: {
+                FORCE_COLOR: '1',
+                ...opts.env
+            }
+        }), this.workspace = workspace;
+        this._logStreams();
+    }
+    // Methods
+    _logStreams() {
+        const off = off$(streamLines$(this, 'stdout').subscribe((line)=>this.logger$.info(line)), streamLines$(this, 'stderr').subscribe((line)=>this.logger$.info(line)));
+        once$(this.events$, 'completed', ()=>{
+            off.unsubscribe();
+        });
+    }
+}
+// Utils
+function isCommandCtx(ctx) {
+    return 'workspace' in ctx && 'command' in ctx;
+}
+
+class ClientError extends Error {
+    name = 'ClientError';
+    constructor(message){
+        super(message);
+    }
+}
+
+// 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 {
+            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;
+}
+
+// Class
+class ScriptTask extends GroupTask {
+    workspace;
+    script;
+    args;
+    // Attributes
+    _preHookTasks = null;
+    _postHookTasks = null;
+    _scriptTasks = null;
+    _runHooks;
+    // Constructor
+    constructor(workspace, script, args, opts){
+        super(script, {
+            workspace,
+            script
+        }, opts), this.workspace = workspace, this.script = script, this.args = args;
+        this._runHooks = opts?.runHooks ?? true;
+    }
+    // Methods
+    async _runScript(script, args) {
+        const line = this.workspace.getScript(script);
+        if (!line) {
+            return null;
+        }
+        // Create command task for script
+        const [command, ...commandArgs] = splitCommandLine(line);
+        const set = new TaskSet();
+        if (!command) {
+            return set;
+        }
+        if (command === 'jill') {
+            const argv = commandArgs.map((arg)=>arg.replace(/^["'](.+)["']$/, '$1'));
+            const { PlannerService } = await import('./planner.service.js');
+            const plannerService = inject$(PlannerService);
+            const tasks = await plannerService.plan(argv, this.workspace.root);
+            if (tasks) {
+                return tasks;
+            }
+        }
+        const pm = await this.workspace.project.packageManager();
+        set.add(new CommandTask(this.workspace, command, [
+            ...commandArgs,
+            ...args
+        ], {
+            logger: this.logger$,
+            superCommand: pm === 'yarn' ? [
+                'yarn',
+                'exec'
+            ] : undefined
+        }));
+        return set;
+    }
+    async prepare() {
+        // Prepare script run
+        this._scriptTasks = await this._runScript(this.script, this.args);
+        if (!this._scriptTasks) {
+            throw new ScriptNotFound(`No script ${this.script} in ${this.workspace.name}`);
+        }
+        // Prepare hooks run
+        if (this._runHooks) {
+            this._preHookTasks = await this._runScript(`pre${this.script}`, []);
+            this._postHookTasks = await this._runScript(`post${this.script}`, []);
+        }
+        // Add tasks to group
+        if (this._preHookTasks) {
+            this.logger$.verbose(`found pre-hook script "pre${this.script}"`);
+            for (const tsk of this._preHookTasks){
+                this.add(tsk);
+            }
+        }
+        for (const tsk of this._scriptTasks){
+            this.add(tsk);
+        }
+        if (this._postHookTasks) {
+            this.logger$.verbose(`found post-hook script "post${this.script}"`);
+            for (const tsk of this._postHookTasks){
+                this.add(tsk);
+            }
+        }
+    }
+    async *onOrchestrate() {
+        if (!this._scriptTasks) {
+            throw new Error('ScriptTask needs to be prepared. Call prepare before starting it');
+        }
+        // Run pre-hook
+        if (this._preHookTasks) {
+            yield* this._preHookTasks;
+            if (await this._hasFailed(this._preHookTasks)) {
+                return this.setStatus('failed');
+            }
+        }
+        // Run script
+        yield* this._scriptTasks;
+        if (await this._hasFailed(this._scriptTasks)) {
+            return this.setStatus('failed');
+        }
+        // Run post-hook
+        if (this._postHookTasks) {
+            yield* this._postHookTasks;
+            if (await this._hasFailed(this._postHookTasks)) {
+                return this.setStatus('failed');
+            }
+        }
+        this.setStatus('done');
+    }
+    async _hasFailed(set) {
+        const results = await waitFor$(set.events$, 'finished');
+        return results.failed > 0;
+    }
+    async onStop() {
+        if (!this._scriptTasks) return;
+        for (const tsk of this._scriptTasks){
+            await tsk.stop();
+        }
+    }
+    complexity(cache = new Map()) {
+        let complexity = super.complexity(cache);
+        if (this._scriptTasks) {
+            complexity += this._scriptTasks.tasks.reduce((cpl, tsk)=>cpl + tsk.complexity(cache), 0);
+        }
+        cache.set(this.id, complexity);
+        return complexity;
+    }
+    // Properties
+    get project() {
+        return this.workspace.project;
+    }
+}
+// Utils
+function isScriptCtx(ctx) {
+    return 'workspace' in ctx && 'script' in ctx;
+}
+class ScriptNotFound extends ClientError {
+    name = 'ScriptNotFound';
+}
+
+var _dec$3, _dec1$2, _initProto$3;
+_dec$3 = instrument({
+    name: 'Workspace.dependencies',
+    use: traceAsyncGenerator
+}), _dec1$2 = instrument({
+    name: 'Workspace.devDependencies',
+    use: traceAsyncGenerator
+});
+class Workspace {
+    manifest;
+    project;
+    static{
+        ({ e: [_initProto$3] } = _(this, [
+            [
+                _dec$3,
+                2,
+                "dependencies"
+            ],
+            [
+                _dec1$2,
+                2,
+                "devDependencies"
+            ]
+        ], []));
+    }
+    // Attributes
+    _affectedCache = (_initProto$3(this), new Map());
+    _logger;
+    _git = inject$(GitService);
+    _root;
+    _tasks = 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(task, 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) {
+                task.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 task = await this.run(script, [], opts);
+        if (!task) {
+            this._logger.warning(`will not be built (no "${script}" script found)`);
+        }
+        return task;
+    }
+    async exec(command, args = [], opts = {}) {
+        const pm = await this.project.packageManager();
+        const task = new CommandTask(this, command, args, {
+            ...opts,
+            logger: this._logger.child(withLabel(`${this.name}$${command}`)),
+            superCommand: pm === 'yarn' ? [
+                'yarn',
+                'exec'
+            ] : undefined
+        });
+        await this._buildDependencies(task, opts);
+        return task;
+    }
+    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 task = this._tasks.get(script);
+        if (!task) {
+            const config = await inject$(CONFIG, asyncScope$());
+            task = new ScriptTask(this, script, args, {
+                ...opts,
+                logger: this._logger.child(withLabel(`${this.name}#${script}`)),
+                runHooks: config.hooks
+            });
+            await task.prepare();
+            await this._buildDependencies(task, opts);
+            this._tasks.set(script, task);
+        }
+        return task;
+    }
+    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;
+    }
+}
+
+var _dec$2, _dec1$1, _dec2, _dec3, _dec4, _initProto$2;
+_dec$2 = instrument('Project.currentWorkspace'), _dec1$1 = instrument('Project.mainWorkspace'), _dec2 = instrument('Project.packageManager'), _dec3 = instrument('Project.workspace'), _dec4 = instrument({
+    name: 'Project.workspaces',
+    use: traceAsyncGenerator
+});
+class Project {
+    static{
+        ({ e: [_initProto$2] } = _(this, [
+            [
+                _dec$2,
+                2,
+                "currentWorkspace"
+            ],
+            [
+                _dec1$1,
+                2,
+                "mainWorkspace"
+            ],
+            [
+                _dec2,
+                2,
+                "packageManager"
+            ],
+            [
+                _dec3,
+                2,
+                "workspace"
+            ],
+            [
+                _dec4,
+                2,
+                "workspaces"
+            ]
+        ], []));
+    }
+    // Attributes
+    _isFullyLoaded = (_initProto$2(this), 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$1, _initProto$1;
+_dec$1 = instrument();
+/**
+ * Helps detecting projects folders
+ */ class ProjectsRepository {
+    static{
+        ({ e: [_initProto$1] } = _(this, [
+            [
+                _dec$1,
+                2,
+                "searchProjectRoot"
+            ]
+        ], []));
+    }
+    // Attributes
+    _cache = (_initProto$1(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);
+        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
+    });
+}
+
+class TaskExpressionError extends ClientError {
+    name = 'TaskExpressionError';
+}
+class TaskSyntaxError extends ClientError {
+    name = 'TaskSyntaxError';
+}
+
+var _dec, _dec1, _initProto;
+_dec = instrument('TaskParserService.parse'), _dec1 = instrument('TaskParserService.buildTask');
+// Service
+class TaskParserService {
+    static{
+        ({ e: [_initProto] } = _(this, [
+            [
+                _dec,
+                2,
+                "parse"
+            ],
+            [
+                _dec1,
+                2,
+                "buildTask"
+            ]
+        ], []));
+    }
+    // Attributes
+    _logger = (_initProto(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 buildTask(node, workspace, opts) {
+        if (TaskParserService.isTaskNode(node)) {
+            const task = await workspace.run(node.script, node.args, opts);
+            if (!task) {
+                throw new TaskExpressionError(`Workspace ${workspace.name} have no ${node.script} script`);
+            }
+            return task;
+        } else {
+            let group;
+            if (node.operator === '//') {
+                group = new ParallelGroup('In parallel', {
+                    workspace
+                }, {
+                    logger: this._logger
+                });
+            } else if (node.operator === '||') {
+                group = new FallbackGroup('Fallbacks', {
+                    workspace
+                }, {
+                    logger: this._logger
+                });
+            } 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;
+                }
+                group = new SequenceGroup('In sequence', {
+                    workspace
+                }, {
+                    logger: this._logger
+                });
+            }
+            for (const child of node.tasks){
+                group.add(await this.buildTask(child, workspace, opts));
+            }
+            return group;
+        }
+    }
+}
+
+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$4 = {
+    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 = pipe$(asyncIterator$(project.workspaces()), hasEveryScript$(scripts), filters.build());
+        // Prepare tasks
+        const tasks = new TaskSet();
+        for await (const wks of workspaces){
+            tasks.add(await taskParser.buildTask(tree.roots[0], wks, {
+                buildScript: args.buildScript,
+                buildDeps: args.depsMode
+            }));
+        }
+        return tasks;
+    }
+};
+
+/**
+ * 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$3 = {
+    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
+        const tasks = new TaskSet();
+        tasks.add(await workspace.exec(args.command, rest, {
+            buildScript: args.buildScript,
+            buildDeps: args.depsMode
+        }));
+        return tasks;
+    },
+    async execute (args, tasks) {
+        const task = tasks.tasks[0];
+        if (task.dependencies.length > 0) {
+            const dependencies = new TaskSet();
+            for (const dep of task.dependencies){
+                dependencies.add(dep);
+            }
+            // Run dependencies first with spinners
+            const { default: TaskExecInk } = await traceLoad('TaskExecInk', ()=>import('./task-exec.ink.js'));
+            await TaskExecInk({
+                tasks: dependencies,
+                verbose: [
+                    'verbose',
+                    'debug'
+                ].includes(args.verbose)
+            });
+        } else {
+            const logger = inject$(LOGGER);
+            logger.verbose('No dependency to build');
+        }
+        const child = cp.spawn(task.cmd, task.args, {
+            stdio: 'inherit',
+            cwd: task.cwd,
+            env: {
+                ...process$1.env,
+                ...task.env
+            },
+            shell: true,
+            windowsHide: true
+        });
+        process$1.exitCode = await new Promise((resolve)=>{
+            child.on('close', (code)=>{
+                resolve(code ?? 0);
+            });
+        });
+    }
+};
+
+// Command
+const command$2 = {
+    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 traceLoad('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$1 = {
+    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(' '));
+        const tasks = new TaskSet();
+        tasks.add(await taskParser.buildTask(tree.roots[0], workspace, {
+            buildScript: args.buildScript,
+            buildDeps: args.depsMode
+        }));
+        return tasks;
+    }
+};
+
+// Command
+const command = {
+    command: 'tree',
+    describe: 'Print workspace dependency tree',
+    builder: withWorkspace,
+    async handler (args) {
+        const workspace = await loadWorkspace(args);
+        const { default: TreeInk } = await traceLoad('TreeInk', ()=>import('./tree.ink.js'));
+        await TreeInk({
+            workspace
+        });
+    }
+};
+
+// 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
+};
+
+// Constants
+const CPU_COUNT = os.cpus().length;
+/**
+ * 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(CPU_COUNT - 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
+});
+
+// Middleware
+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$}?#}`;
+
+// Utils
+const VERBOSITY_LEVEL = {
+    1: 'verbose',
+    2: 'debug'
+};
+// Middleware
+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
+function baseParser() {
+    return pipe$(yargs().scriptName('jill').version(version).demandCommand().recommendCommands(), withLogger, withConfig);
+}
+/**
+ * Prepare parser executing commands
+ */ function executeParser() {
+    return pipe$(baseParser(), executeCommand(command$4), executeCommand(command$3), command$5(command$2), executeCommand(command$1), command$5(command));
+}
+/**
+ * Prepare parser planning commands
+ */ function planParser(tasks$) {
+    return pipe$(baseParser(), planCommand(command$4, tasks$), planCommand(command$3, tasks$), planCommand(command$2, tasks$), planCommand(command$1, tasks$), planCommand(command, tasks$));
+}
+
+export { ClientError as C, LOGGER as L, ScriptTask as S, TASK_MANAGER as T, isScriptCtx as a, CommandTask as b, capitalize as c, CWD as d, executeParser as e, ConfigService as f, instrument as g, isCommandCtx as i, logFormat as l, planParser as p };
+//# sourceMappingURL=parser.js.map