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

package/dist/parser.js

@@ -0,0 +1,1879 @@
+import { TaskManager, plan, SpawnTask, GroupTask, TaskSet, ParallelGroup, FallbackGroup, SequenceGroup } from '@jujulego/tasks';
+import { token$, inject$, asyncScope$ } from '@kyrielle/injector';
+import { waitFor$, filter$, observable$, off$, once$, pipe$, map$, collect$, asyncIterator$, var$, flow$ } from 'kyrielle';
+import { logger$, withTimestamp, withLabel, LogLevel, qLogDelay, LogGateway, logDelay$, toStderr } from '@kyrielle/logger';
+import path from 'node:path';
+import { Glob } from 'glob';
+import fs from 'node:fs';
+import normalize from 'normalize-package-data';
+import { satisfies, compare, parse } from 'semver';
+import moo from 'moo';
+import cp from 'node:child_process';
+import process$1 from 'node:process';
+import chalk from 'chalk';
+import slugify from 'slugify';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { PathScurry } from 'path-scurry';
+import { qjson, defineQuickFormat, qprop, q$, 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.2";
+
+function command$5(module) {
+    return (parser)=>parser.command(module);
+}
+
+// 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 ()=>{
+    return new TaskManager({
+        jobs: (await inject$(CONFIG, asyncScope$())).jobs,
+        logger: inject$(LOGGER)
+    });
+});
+
+// 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, execute, ...rest } = module;
+    return command$5({
+        ...rest,
+        builder (base) {
+            const parser = withPlanMode(base);
+            if (rest.builder) {
+                return rest.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 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 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, ...rest } = module;
+        return command$5({
+            ...rest,
+            builder (base) {
+                const parser = withPlanMode(base);
+                if (rest.builder) {
+                    return rest.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);
+            }
+        }));
+    });
+}
+
+class GitService {
+    // Attributes
+    _manager = 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;
+}
+
+// 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 Error(`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 Workspace {
+    manifest;
+    project;
+    // Attributes
+    _affectedCache = 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;
+    }
+}
+
+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);
+    }
+}
+
+/**
+ * Helps detecting projects folders
+ */ class ProjectsRepository {
+    // Attributes
+    _cache = 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(async (args)=>{
+        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 Error {
+}
+class TaskSyntaxError extends Error {
+}
+
+// Service
+class TaskParserService {
+    // Attributes
+    _logger = 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 Error(`Workspace "${args.workspace || '.'}" not found`);
+    }
+    return workspace;
+}
+
+// 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 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 Error(`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 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 import('./tree.ink.js');
+        await TreeInk({
+            workspace
+        });
+    }
+};
+
+// Utils
+async 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 configMiddleware(parser) {
+    return parser.option('config-file', {
+        alias: 'c',
+        type: 'string',
+        description: 'Configuration file'
+    }).middleware(async (args)=>{
+        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 loggerMiddleware(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)=>{
+        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(hideBin(process$1.argv)).scriptName('jill').version(version).demandCommand().recommendCommands(), loggerMiddleware, configMiddleware);
+}
+/**
+ * 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 { CommandTask as C, LOGGER as L, ScriptTask as S, TASK_MANAGER as T, isScriptCtx as a, CWD as b, capitalize as c, ConfigService as d, executeParser as e, isCommandCtx as i, logFormat as l, planParser as p };
+//# sourceMappingURL=parser.js.map