@jujulego/jill 3.0.0-alpha.10 → 3.0.0-alpha.11

package/dist/main.js

@@ -1,21 +1,21 @@
-;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d71a4689-40f0-48b6-8162-43fd470f2d95",e._sentryDebugIdIdentifier="sentry-dbid-d71a4689-40f0-48b6-8162-43fd470f2d95");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.10"};}catch(e){}}();import { token$, inject$, asyncScope$ } from '@kyrielle/injector';
-import { startInactiveSpan, startSpan, getActiveSpan, updateSpanName, getRootSpan, captureException } from '@sentry/node';
-import { filter$, waitFor$, pipe$, map$, collect$, asyncIterator$, var$, flow$ } from 'kyrielle';
+;{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]="1635b077-95c7-4391-8a7c-36d52dbe9982",e._sentryDebugIdIdentifier="sentry-dbid-1635b077-95c7-4391-8a7c-36d52dbe9982");})();}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.11"};}catch(e){}}();import { token$, inject$, asyncScope$ } from '@kyrielle/injector';
+import { startSpan, startInactiveSpan, getActiveSpan, updateSpanName, getRootSpan, captureException } from '@sentry/node';
+import { pipe$, waitFor$, var$, filter$, collect$, map$, asyncIterator$, flow$ } from 'kyrielle';
 import process$1 from 'node:process';
 import { hideBin } from 'yargs/helpers';
-import { scheduler$, isWorkloadEnded, WorkloadState, spawn$, parallelFlow$, fallbackFlow$, sequenceFlow$ } from '@jujulego/tasks';
-import { logger$, withTimestamp, LogLevel, withLabel, qLogDelay, LogGateway, logDelay$, toStderr } from '@kyrielle/logger';
+import { scheduler$, isWorkloadEnded, WorkloadState, spawn$, sequenceFlow$, parallelFlow$, fallbackFlow$ } from '@kyrielle/workload';
+import path from 'node:path';
 import { _ } from '@swc/helpers/_/_apply_decs_2203_r';
-import { text } from 'node:stream/consumers';
+import { logger$, withTimestamp, LogLevel, withLabel, qLogDelay, LogGateway, logDelay$, toStderr } from '@kyrielle/logger';
 import fs from 'node:fs';
 import { PathScurry } from 'path-scurry';
-import assert from 'assert';
-import { Writable } from 'node:stream';
-import moo from 'moo';
-import path from 'node:path';
 import { Glob } from 'glob';
 import normalize from 'normalize-package-data';
 import { satisfies, compare, parse } from 'semver';
+import assert from 'assert';
+import { Writable } from 'node:stream';
+import { text } from 'node:stream/consumers';
+import moo from 'moo';
 import { spawn } from 'node:child_process';
 import chalk from 'chalk';
 import slugify from 'slugify';
@@ -26,27 +26,37 @@ import os from 'node:os';
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
 import { chalkTemplateStderr } from 'chalk-template';
 
-// Filter
-function hasSomeScript$(scripts) {
-    return filter$((wks)=>{
-        if (!wks.manifest.scripts) {
-            return false;
-        }
-        return scripts.some((script)=>script in wks.manifest.scripts);
-    });
+function trace(fun, opts) {
+    const name = typeof opts === 'string' ? opts : opts.name;
+    const op = typeof opts === 'object' ? opts.op : undefined;
+    const use = typeof opts === 'object' && opts.use || ((_, r)=>r);
+    return function(...args) {
+        return pipe$(startSpan({
+            name,
+            op
+        }, ()=>fun.call(this, ...args)), (r)=>use(name, r));
+    };
 }
-function hasEveryScript$(scripts) {
-    return filter$((wks)=>{
-        if (!wks.manifest.scripts) {
-            return false;
-        }
-        return scripts.every((script)=>script in wks.manifest.scripts);
-    });
+function instrument(opts) {
+    return (target, context)=>{
+        const name = typeof opts === 'string' ? opts : opts?.name ?? context.name.toString();
+        const use = typeof opts === 'object' ? opts.use : (_, r)=>r;
+        return trace(target, {
+            name,
+            use
+        });
+    };
+}
+function traceImport(name, loader) {
+    return startSpan({
+        name: name,
+        op: 'resource.script'
+    }, loader);
 }
 
 // Tokens
 const CONFIG = token$('Config', async ()=>{
-    const { ConfigService } = await Promise.resolve().then(function () { return config_service; });
+    const { ConfigService } = await traceImport('ConfigService', ()=>Promise.resolve().then(function () { return config_service; }));
     return waitFor$(inject$(ConfigService, asyncScope$()).config$);
 });
 const CWD = token$('cwd', ()=>process$1.cwd());
@@ -107,46 +117,32 @@ const SCHEDULER = token$('Scheduler', async ()=>{
     return scheduler;
 });
 
-function trace(fun, opts) {
-    const name = typeof opts === 'string' ? opts : opts.name;
-    const op = typeof opts === 'object' ? opts.op : undefined;
-    const use = typeof opts === 'object' && opts.use || ((_, r)=>r);
-    return function(...args) {
-        return pipe$(startSpan({
-            name,
-            op
-        }, ()=>fun.call(this, ...args)), (r)=>use(name, r));
-    };
-}
-function instrument(opts) {
-    return (target, context)=>{
-        const name = typeof opts === 'string' ? opts : opts?.name ?? context.name.toString();
-        const use = typeof opts === 'object' ? opts.use : (_, r)=>r;
-        return trace(target, {
-            name,
-            use
-        });
+function 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);
+            }
+        }
     };
 }
-function traceImport(name, loader) {
-    return startSpan({
-        name: name,
-        op: 'resource.script'
-    }, loader);
-}
-
-class ClientError extends Error {
-    name = 'ClientError';
-    constructor(message){
-        super(message);
+async function with$(lock, fn) {
+    try {
+        await lock.acquire();
+        return await fn();
+    } finally{
+        lock.release();
     }
 }
-class TaskExpressionError extends ClientError {
-    name = 'TaskExpressionError';
-}
-class TaskSyntaxError extends ClientError {
-    name = 'TaskSyntaxError';
-}
 
 function logStreamedLines(logger, level) {
     let leftover = '';
@@ -170,6 +166,140 @@ function logStreamedLines(logger, level) {
     });
 }
 
+function command$(workspace, cmd, opts = {}) {
+    const { superCommand, logger = inject$(LOGGER), ...rest } = opts;
+    // Apply super command
+    if (superCommand) {
+        cmd = superCommand + ' ' + cmd;
+    }
+    // Prepare job
+    const job = spawn$(cmd, {
+        ...rest,
+        cwd: workspace.root,
+        env: {
+            FORCE_COLOR: '1',
+            ...rest.env
+        },
+        shell: true
+    });
+    job.stdout.pipe(logStreamedLines(logger, LogLevel.info));
+    job.stderr.pipe(logStreamedLines(logger, LogLevel.info));
+    return job;
+}
+
+class ClientError extends Error {
+    name = 'ClientError';
+    constructor(message){
+        super(message);
+    }
+}
+class TaskExpressionError extends ClientError {
+    name = 'TaskExpressionError';
+}
+class TaskSyntaxError extends ClientError {
+    name = 'TaskSyntaxError';
+}
+
+// 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;
+}
+function escapeCommandLineArg(arg) {
+    if (arg.match(/[ ()]/)) {
+        return `"${arg.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+    }
+    return arg;
+}
+
+async function runScript$(workspace, script, args, opts = {}) {
+    // Run script itself
+    const jobs = [
+        await planScript$(workspace, script, args, opts)
+    ];
+    if (!jobs[0]) {
+        throw new ScriptNotFound(`No script ${script} in ${workspace.name}`);
+    }
+    // Run hooks
+    if (opts.runHooks) {
+        jobs.unshift(await planScript$(workspace, `pre${script}`, [], opts));
+        jobs.push(await planScript$(workspace, `post${script}`, [], opts));
+    }
+    // Prepare workflow
+    const flow = pipe$(jobs, filter$((job)=>job !== null), collect$(sequenceFlow$({
+        label: script,
+        type: 'script'
+    })));
+    return {
+        ...flow,
+        script,
+        workspace
+    };
+}
+// Utils
+async function planScript$(workspace, script, args, opts) {
+    // Load script
+    let line = workspace?.getScript(script);
+    if (!line) {
+        return null;
+    }
+    // Parse script
+    const [command, ...commandArgs] = splitCommandLine(line);
+    if (!command) {
+        return null;
+    }
+    if (command === 'jill') {
+        const argv = [
+            ...commandArgs,
+            ...args
+        ].map((arg)=>arg.replace(/^["'](.+)["']$/, '$1'));
+        const { PlannerService } = await traceImport('PlannerService', ()=>import('./planner.service.js'));
+        const plannerService = inject$(PlannerService);
+        const job = await plannerService.plan(argv, workspace.root);
+        if (job) {
+            return job;
+        }
+    }
+    // Run command
+    const pm = await workspace.project.packageManager();
+    line = [
+        line,
+        args.map(escapeCommandLineArg)
+    ].join(' ').trim();
+    return command$(workspace, line, {
+        logger: opts.logger,
+        superCommand: pm === 'yarn' && command !== 'yarn' ? 'yarn exec' : undefined
+    });
+}
+class ScriptNotFound extends ClientError {
+    name = 'ScriptNotFound';
+}
+
 var _dec$2, _dec1$1, _dec2, _initProto$2;
 _dec$2 = instrument('GitService.isAffected'), _dec1$1 = instrument('GitService.listBranches'), _dec2 = instrument('GitService.listTags');
 class GitService {
@@ -198,13 +328,13 @@ class GitService {
     // Methods
     /**
    * Runs a git command inside
-   */ async command(cmd, args, opts = {}) {
+   */ async command(cmd, opts = {}) {
         const { logger = this._logger, ...props } = opts;
         // Create job
-        const job = spawn$('git', [
-            cmd,
-            ...args
-        ], props);
+        const job = spawn$(`git ${cmd}`, {
+            ...props,
+            shell: true
+        });
         job.stdout.pipe(logStreamedLines(logger, LogLevel.debug));
         job.stderr.pipe(logStreamedLines(logger, LogLevel.warning));
         (await this._scheduler).register(job);
@@ -213,17 +343,17 @@ class GitService {
     /**
    * Runs git branch
    */ branch(args, opts) {
-        return this.command('branch', args, opts);
+        return this.command(`branch ${args.join(' ')}`, opts);
     }
     /**
    * Runs git diff
    */ diff(args, opts) {
-        return this.command('diff', args, opts);
+        return this.command(`diff ${args.join(' ')}`, opts);
     }
     /**
    * Runs git tag
    */ tag(args, opts) {
-        return this.command('tag', args, opts);
+        return this.command(`tag ${args.join(' ')}`, opts);
     }
     /**
    * Uses git diff to detect if given files have been affected since given reference
@@ -265,873 +395,728 @@ class GitService {
     }
 }
 
-// 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;
-                }
-            }
-        }());
-    };
+// Utils
+async function* combine(...generators) {
+    for (const gen of generators){
+        yield* gen;
+    }
 }
-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
+
+class Workspace {
+    manifest;
+    project;
+    // Attributes
+    _affectedCache = new Map();
+    _logger;
+    _git = inject$(GitService);
+    _root;
+    _jobs = new Map();
+    // Constructor
+    constructor(root, manifest, project){
+        this.manifest = manifest;
+        this.project = project;
+        this._root = root;
+        this._logger = inject$(LOGGER).child(withLabel(manifest.name));
+    }
+    // Methods
+    async _buildDependencies(job, opts) {
+        const generators = [];
+        switch(opts.buildDeps ?? 'all'){
+            case 'all':
+                generators.unshift(this.devDependencies());
+            // eslint-disable-next no-fallthrough
+            case 'prod':
+                generators.unshift(this.dependencies());
+        }
+        // Build deps
+        for await (const dep of combine(...generators)){
+            const build = await dep.build(opts);
+            if (build) {
+                job.dependsOn(build);
+            }
+        }
+    }
+    async *_loadDependencies(dependencies, kind) {
+        for (const [dep, range] of Object.entries(dependencies)){
+            const ws = await this.project.workspace(dep);
+            if (ws) {
+                if (ws._satisfies(this, range)) {
+                    yield ws;
+                } else {
+                    this._logger.warning(`ignoring ${kind} ${ws.reference} as it does not match requirement ${range}`);
+                }
+            }
+        }
+    }
+    async _isAffected(reference) {
+        const isAffected = await this._git.isAffected(reference, [
+            this.root
         ], {
-            cwd: workspace.root,
-            logger: logger
+            cwd: this.project.root,
+            logger: this._logger
         });
-        if (branches.length > 0) {
-            result = branches[branches.length - 1];
+        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);
     }
-    // - search in tags
-    if (result.includes('*')) {
-        const tags = await git.listTags([
-            ...sortArgs,
-            result
-        ], {
-            cwd: workspace.root,
-            logger: logger
+    _satisfies(from, range) {
+        if (range.startsWith('file:')) {
+            return path.resolve(from.root, range.substring(5)) === this.root;
+        }
+        if (range.startsWith('workspace:')) {
+            range = range.substring(10);
+        }
+        return !this.version || satisfies(this.version, range);
+    }
+    async isAffected(reference) {
+        let isAffected = this._affectedCache.get(reference);
+        if (!isAffected) {
+            isAffected = this._isAffected(reference);
+            this._affectedCache.set(reference, isAffected);
+        }
+        return await isAffected;
+    }
+    async *dependencies() {
+        if (!this.manifest.dependencies) return;
+        for await (const ws of this._loadDependencies(this.manifest.dependencies, 'dependency')){
+            yield ws;
+        }
+    }
+    async *devDependencies() {
+        if (!this.manifest.devDependencies) return;
+        for await (const ws of this._loadDependencies(this.manifest.devDependencies, 'devDependency')){
+            yield ws;
+        }
+    }
+    async build(opts = {}) {
+        const script = opts.buildScript ?? 'build';
+        const job = await this.run(script, [], opts);
+        if (!job) {
+            this._logger.warning(`will not be built (no "${script}" script found)`);
+        }
+        return job;
+    }
+    async exec(command, opts = {}) {
+        const pm = await this.project.packageManager();
+        const job = command$(this, command, {
+            ...opts,
+            logger: this._logger.child(withLabel(`${this.name}$${command}`)),
+            superCommand: pm === 'yarn' ? 'yarn exec' : undefined
         });
-        if (tags.length > 0) {
-            result = tags[tags.length - 1];
+        await this._buildDependencies(job, opts);
+        return job;
+    }
+    getScript(script) {
+        const { scripts = {} } = this.manifest;
+        return scripts[script] || null;
+    }
+    async run(script, args = [], opts = {}) {
+        // Script not found
+        if (!this.getScript(script)) {
+            return null;
+        }
+        // Create task if it doesn't exist yet
+        let job = this._jobs.get(script);
+        if (!job) {
+            const config = await inject$(CONFIG, asyncScope$());
+            job = await runScript$(this, script, args, {
+                ...opts,
+                logger: this._logger.child(withLabel(`${this.name}#${script}`)),
+                runHooks: config.hooks
+            });
+            await this._buildDependencies(job, opts);
+            this._jobs.set(script, job);
         }
+        return job;
     }
-    if (result !== opts.format) {
-        logger.verbose(`resolved ${opts.format} into ${result}`);
+    // Properties
+    get name() {
+        return this.manifest.name;
     }
-    if (result.includes('*')) {
-        logger.warning(`no revision found matching ${result}, using fallback ${opts.fallback}`);
-        return opts.fallback;
+    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;
     }
-    return result;
-}
-
-// Filter
-function isPrivate$(value) {
-    return filter$((wks)=>(wks.manifest.private ?? false) === value);
 }
 
-var _dec$1, _dec1, _initProto$1;
-_dec$1 = instrument('TaskParserService.parse'), _dec1 = instrument('TaskParserService.buildJob');
-// Service
-class TaskParserService {
-    static{
-        ({ e: [_initProto$1] } = _(this, [
-            [
-                _dec$1,
-                2,
-                "parse"
-            ],
-            [
-                _dec1,
-                2,
-                "buildJob"
-            ]
-        ], []));
-    }
+class Project {
     // Attributes
-    _logger = (_initProto$1(this), inject$(LOGGER).child(withLabel('task-parser')));
-    // Statics
-    static isTaskNode(node) {
-        return 'script' in node;
+    _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;
+        }
     }
-    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')
-                    }
-                ]
+    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;
         });
     }
-    _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);
+    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 node;
+        return workspace;
     }
-    parse(expr) {
-        const lexer = this._lexer().reset(expr);
-        const tree = {
-            roots: []
-        };
-        while(true){
-            const node = this._nextNode(lexer);
-            if (node) {
-                tree.roots.push(node);
+    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 {
-                break;
+                this._logger.debug`no package manager recognized in ${this.root}, defaults to npm`;
+                this._packageManager = 'npm';
             }
         }
-        return tree;
+        return this._packageManager;
     }
-    *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 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 buildJob(node, workspace, opts) {
-        if (TaskParserService.isTaskNode(node)) {
-            const job = await workspace.run(node.script, node.args, opts);
-            if (!job) {
-                throw new TaskExpressionError(`Workspace ${workspace.name} have no ${node.script} script`);
+    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;
             }
-            return job;
         } else {
-            let flow;
-            if (node.operator === '//') {
-                flow = parallelFlow$({
-                    label: 'In parallel'
-                });
-            } else if (node.operator === '||') {
-                flow = fallbackFlow$({
-                    label: 'Fallbacks'
-                });
-            } else {
-                if (node.operator === '->' && TaskParserService._sequenceOperatorWarn) {
-                    this._logger.warn('Sequence operator -> is deprecated in favor of &&. It will be removed in a next major release.');
-                    TaskParserService._sequenceOperatorWarn = true;
+            // 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;
                 }
-                flow = sequenceFlow$({
-                    label: 'In sequence'
-                });
-            }
-            for (const child of node.tasks){
-                flow.push(await this.buildJob(child, workspace, opts));
             }
-            return flow;
+            this._isFullyLoaded = true;
         }
     }
+    // Properties
+    get root() {
+        return path.resolve(this._root);
+    }
 }
 
-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();
+var _dec$1, _initProto$1;
+_dec$1 = instrument();
+/**
+ * Helps detecting projects folders
+ */ class ProjectsRepository {
+    static{
+        ({ e: [_initProto$1] } = _(this, [
+            [
+                _dec$1,
+                2,
+                "searchProjectRoot"
+            ]
+        ], []));
     }
-}
-
-function command$(workspace, cmd, args, opts = {}) {
-    const { superCommand, logger = inject$(LOGGER), ...rest } = opts;
-    // Apply super command
-    if (superCommand) {
-        if (typeof superCommand === 'string') {
-            args = [
-                cmd,
-                ...args
-            ];
-            cmd = superCommand;
-        } else if (superCommand.length) {
-            args = [
-                ...superCommand.slice(1),
-                cmd,
-                ...args
-            ];
-            cmd = superCommand[0];
+    // 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);
+        // Test all ancestors
+        let foundManifest = false;
+        let projectRoot = directory;
+        let dir = directory;
+        let prev = dir;
+        do {
+            // Look for files
+            const { hasManifest, hasLockFile } = await this.isProjectRoot(dir);
+            if (hasManifest) {
+                projectRoot = dir;
+                foundManifest = true;
+            }
+            if (hasLockFile) {
+                break;
+            }
+            prev = dir;
+            dir = path.dirname(dir);
+        }while (prev !== dir);
+        // Log it
+        if (foundManifest) {
+            this._logger.verbose`project root found at ${projectRoot}`;
+        } else {
+            this._logger.verbose`project root not found, keeping ${projectRoot}`;
         }
+        return projectRoot;
     }
-    // Prepare job
-    const job = spawn$(cmd, args, {
-        ...rest,
-        cwd: workspace.root,
-        env: {
-            FORCE_COLOR: '1',
-            ...rest.env
+    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
     });
-    job.stdout.pipe(logStreamedLines(logger, LogLevel.info));
-    job.stderr.pipe(logStreamedLines(logger, LogLevel.info));
-    return job;
 }
 
-// Utils
-function capitalize(txt) {
-    return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
+// Filter
+function hasSomeScript$(scripts) {
+    return filter$((wks)=>{
+        if (!wks.manifest.scripts) {
+            return false;
+        }
+        return scripts.some((script)=>script in wks.manifest.scripts);
+    });
 }
-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;
-            }
+function hasEveryScript$(scripts) {
+    return filter$((wks)=>{
+        if (!wks.manifest.scripts) {
+            return false;
         }
-    }
-    parts.push(line.slice(last));
-    return parts;
+        return scripts.every((script)=>script in wks.manifest.scripts);
+    });
 }
 
-async function runScript$(workspace, script, args, opts = {}) {
-    // Run script itself
-    const jobs = [
-        await planScript$(workspace, script, args, opts)
-    ];
-    if (!jobs[0]) {
-        throw new ScriptNotFound(`No script ${script} in ${workspace.name}`);
-    }
-    // Run hooks
-    if (opts.runHooks) {
-        jobs.unshift(await planScript$(workspace, `pre${script}`, [], opts));
-        jobs.push(await planScript$(workspace, `post${script}`, [], opts));
-    }
-    // Prepare workflow
-    const flow = pipe$(jobs, filter$((job)=>job !== null), collect$(sequenceFlow$({
-        label: script,
-        type: 'script'
-    })));
-    return {
-        ...flow,
-        script,
-        workspace
+// 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;
+                }
+            }
+        }());
     };
 }
-// Utils
-async function planScript$(workspace, script, args, opts) {
-    // Load script
-    const line = workspace?.getScript(script);
-    if (!line) {
-        return null;
-    }
-    // Parse script
-    const [command, ...commandArgs] = splitCommandLine(line);
-    if (!command) {
-        return null;
+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];
+        }
     }
-    if (command === 'jill') {
-        const argv = commandArgs.map((arg)=>arg.replace(/^["'](.+)["']$/, '$1'));
-        const { PlannerService } = await import('./planner.service.js');
-        const plannerService = inject$(PlannerService);
-        const job = await plannerService.plan(argv, workspace.root);
-        if (job) {
-            return job;
+    // - 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];
         }
     }
-    // Run command
-    const pm = await workspace.project.packageManager();
-    return command$(workspace, command, [
-        ...commandArgs,
-        ...args
-    ], {
-        logger: opts.logger,
-        superCommand: pm === 'yarn' && command !== 'yarn' ? [
-            'yarn',
-            'exec'
-        ] : undefined
-    });
-}
-class ScriptNotFound extends ClientError {
-    name = 'ScriptNotFound';
+    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;
 }
 
-// Utils
-async function* combine(...generators) {
-    for (const gen of generators){
-        yield* gen;
-    }
+// Filter
+function isPrivate$(value) {
+    return filter$((wks)=>(wks.manifest.private ?? false) === value);
 }
 
-class Workspace {
-    manifest;
-    project;
+var _dec, _dec1, _initProto;
+_dec = instrument('TaskParserService.parse'), _dec1 = instrument('TaskParserService.buildJob');
+// Service
+class TaskParserService {
+    static{
+        ({ e: [_initProto] } = _(this, [
+            [
+                _dec,
+                2,
+                "parse"
+            ],
+            [
+                _dec1,
+                2,
+                "buildJob"
+            ]
+        ], []));
+    }
     // Attributes
-    _affectedCache = new Map();
-    _logger;
-    _git = inject$(GitService);
-    _root;
-    _jobs = new Map();
-    // Constructor
-    constructor(root, manifest, project){
-        this.manifest = manifest;
-        this.project = project;
-        this._root = root;
-        this._logger = inject$(LOGGER).child(withLabel(manifest.name));
+    _logger = (_initProto(this), inject$(LOGGER).child(withLabel('task-parser')));
+    // Statics
+    static isTaskNode(node) {
+        return 'script' in node;
     }
+    static _sequenceOperatorWarn = true;
     // Methods
-    async _buildDependencies(job, opts) {
-        const generators = [];
-        switch(opts.buildDeps ?? 'all'){
-            case 'all':
-                generators.unshift(this.devDependencies());
-            // eslint-disable-next no-fallthrough
-            case 'prod':
-                generators.unshift(this.dependencies());
-        }
-        // Build deps
-        for await (const dep of combine(...generators)){
-            const build = await dep.build(opts);
-            if (build) {
-                job.dependsOn(build);
+    _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')
+                    }
+                ]
             }
-        }
+        });
     }
-    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;
+    _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 {
-                    this._logger.warning(`ignoring ${kind} ${ws.reference} as it does not match requirement ${range}`);
+                    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;
             }
-        }
-    }
-    async _isAffected(reference) {
-        const isAffected = await this._git.isAffected(reference, [
-            this.root
-        ], {
-            cwd: this.project.root,
-            logger: this._logger
-        });
-        if (isAffected) {
-            return true;
-        }
-        // Test dependencies
-        const proms = [];
-        for await (const dep of combine(this.dependencies(), this.devDependencies())){
-            proms.push(dep.isAffected(reference));
-        }
-        const results = await Promise.all(proms);
-        return results.some((r)=>r);
-    }
-    _satisfies(from, range) {
-        if (range.startsWith('file:')) {
-            return path.resolve(from.root, range.substring(5)) === this.root;
-        }
-        if (range.startsWith('workspace:')) {
-            range = range.substring(10);
-        }
-        return !this.version || satisfies(this.version, range);
-    }
-    async isAffected(reference) {
-        let isAffected = this._affectedCache.get(reference);
-        if (!isAffected) {
-            isAffected = this._isAffected(reference);
-            this._affectedCache.set(reference, isAffected);
-        }
-        return await isAffected;
-    }
-    async *dependencies() {
-        if (!this.manifest.dependencies) return;
-        for await (const ws of this._loadDependencies(this.manifest.dependencies, 'dependency')){
-            yield ws;
-        }
-    }
-    async *devDependencies() {
-        if (!this.manifest.devDependencies) return;
-        for await (const ws of this._loadDependencies(this.manifest.devDependencies, 'devDependency')){
-            yield ws;
-        }
-    }
-    async build(opts = {}) {
-        const script = opts.buildScript ?? 'build';
-        const job = await this.run(script, [], opts);
-        if (!job) {
-            this._logger.warning(`will not be built (no "${script}" script found)`);
-        }
-        return job;
-    }
-    async exec(command, args = [], opts = {}) {
-        const pm = await this.project.packageManager();
-        const job = command$(this, command, args, {
-            ...opts,
-            logger: this._logger.child(withLabel(`${this.name}$${command}`)),
-            superCommand: pm === 'yarn' ? [
-                'yarn',
-                'exec'
-            ] : undefined
-        });
-        await this._buildDependencies(job, opts);
-        return job;
-    }
-    getScript(script) {
-        const { scripts = {} } = this.manifest;
-        return scripts[script] || null;
-    }
-    async run(script, args = [], opts = {}) {
-        // Script not found
-        if (!this.getScript(script)) {
-            return null;
-        }
-        // Create task if it doesn't exist yet
-        let job = this._jobs.get(script);
-        if (!job) {
-            const config = await inject$(CONFIG, asyncScope$());
-            job = await runScript$(this, script, args, {
-                ...opts,
-                logger: this._logger.child(withLabel(`${this.name}#${script}`)),
-                runHooks: config.hooks
-            });
-            await this._buildDependencies(job, opts);
-            this._jobs.set(script, job);
-        }
-        return job;
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            version: this.version,
-            root: this.root
-        };
-    }
-    // Properties
-    get name() {
-        return this.manifest.name;
-    }
-    get reference() {
-        return this.version ? `${this.name}@${this.version}` : this.name;
-    }
-    get root() {
-        return path.resolve(this.project.root, this._root);
-    }
-    get version() {
-        return this.manifest.version;
-    }
-}
-
-class Project {
-    // Attributes
-    _isFullyLoaded = false;
-    _lock = mutex$();
-    _mainWorkspace;
-    _packageManager;
-    _workspaceGlob;
-    _names = new Map();
-    _logger = inject$(LOGGER).child(withLabel('project'));
-    _root;
-    _scurry = inject$(PATH_SCURRY);
-    _workspaces = new Map();
-    // Constructor
-    constructor(root, opts = {}){
-        this._root = root;
-        if (opts.packageManager) {
-            this._logger.verbose`Forced use of ${opts.packageManager} in ${root}`;
-            this._packageManager = opts.packageManager;
-        }
-    }
-    // Methods
-    async _loadManifest(dir) {
-        const file = path.resolve(this.root, dir, 'package.json');
-        const relative = path.relative(this.root, path.dirname(file));
-        const logger = this._logger.child(withLabel(relative ? `project@${relative}` : 'project'));
-        logger.debug('loading package.json ...');
-        const data = await fs.promises.readFile(file, 'utf-8');
-        const mnf = JSON.parse(data);
-        normalize(mnf, (msg)=>logger.verbose(msg));
-        return mnf;
-    }
-    _loadWorkspace(dir) {
-        return with$(this._lock, async ()=>{
-            let wks = this._workspaces.get(dir);
-            if (!wks) {
-                const manifest = await this._loadManifest(dir);
-                wks = new Workspace(dir, manifest, this);
-                this._workspaces.set(dir, wks);
-                this._names.set(wks.name, wks);
+            // 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'));
             }
-            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;
+            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 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;
+        return node;
     }
-    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';
+    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 {
-                this._logger.debug`no package manager recognized in ${this.root}, defaults to npm`;
-                this._packageManager = 'npm';
+                break;
             }
         }
-        return this._packageManager;
+        return tree;
     }
-    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;
-                }
+    *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);
             }
-            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;
+    async buildJob(node, workspace, opts) {
+        if (TaskParserService.isTaskNode(node)) {
+            const job = await workspace.run(node.script, node.args, opts);
+            if (!job) {
+                throw new TaskExpressionError(`Workspace ${workspace.name} have no ${node.script} script`);
             }
+            return job;
         } else {
-            // 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;
+            let flow;
+            if (node.operator === '//') {
+                flow = parallelFlow$({
+                    label: 'In parallel'
+                });
+            } else if (node.operator === '||') {
+                flow = fallbackFlow$({
+                    label: 'Fallbacks'
+                });
+            } else {
+                if (node.operator === '->' && TaskParserService._sequenceOperatorWarn) {
+                    this._logger.warn('Sequence operator -> is deprecated in favor of &&. It will be removed in a next major release.');
+                    TaskParserService._sequenceOperatorWarn = true;
                 }
+                flow = sequenceFlow$({
+                    label: 'In sequence'
+                });
             }
-            this._isFullyLoaded = true;
-        }
-    }
-    // Properties
-    get root() {
-        return path.resolve(this._root);
-    }
-}
-
-var _dec, _initProto;
-_dec = instrument();
-/**
- * Helps detecting projects folders
- */ class ProjectsRepository {
-    static{
-        ({ e: [_initProto] } = _(this, [
-            [
-                _dec,
-                2,
-                "searchProjectRoot"
-            ]
-        ], []));
-    }
-    // Attributes
-    _cache = (_initProto(this), new Map());
-    _logger = inject$(LOGGER).child(withLabel('projects'));
-    _scurry = inject$(PATH_SCURRY);
-    // Methods
-    async isProjectRoot(dir) {
-        this._logger.debug`testing ${dir}`;
-        const files = await this._scurry.readdir(dir, {
-            withFileTypes: false
-        });
-        return {
-            hasManifest: files.includes(MANIFEST),
-            hasLockFile: LOCK_FILES.some((lock)=>files.includes(lock))
-        };
-    }
-    async searchProjectRoot(directory) {
-        directory = path.resolve(directory);
-        // Test all ancestors
-        let foundManifest = false;
-        let projectRoot = directory;
-        let dir = directory;
-        let prev = dir;
-        do {
-            // Look for files
-            const { hasManifest, hasLockFile } = await this.isProjectRoot(dir);
-            if (hasManifest) {
-                projectRoot = dir;
-                foundManifest = true;
-            }
-            if (hasLockFile) {
-                break;
+            for (const child of node.tasks){
+                flow.push(await this.buildJob(child, workspace, opts));
             }
-            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 flow;
         }
-        return project;
     }
 }
-// Constants
-const MANIFEST = 'package.json';
-const LOCK_FILES = [
-    'package-lock.json',
-    'yarn.lock'
-];
-
-/**
- * Adds arguments to load a project.
- */ function withProject(parser) {
-    return parser.option('project', {
-        alias: 'p',
-        type: 'string',
-        default: '',
-        defaultDescription: 'current working directory',
-        description: 'Project root directory',
-        normalize: true
-    }).option('package-manager', {
-        choices: [
-            'yarn',
-            'npm'
-        ],
-        type: 'string',
-        description: 'Force package manager'
-    }).middleware((args)=>startSpan({
-            name: 'project',
-            op: 'cli.middleware'
-        }, async ()=>{
-            const repository = inject$(ProjectsRepository);
-            const directory = path.resolve(inject$(CWD, asyncScope$()), args.project);
-            args.project = await repository.searchProjectRoot(directory);
-        }));
-}
-/**
- * Loads a project, based on arguments.
- */ function loadProject(args) {
-    const repository = inject$(ProjectsRepository);
-    return repository.getProject(args.project, {
-        packageManager: args.packageManager
-    });
-}
 
 function pipeline$() {
     const steps = [];
@@ -1304,17 +1289,22 @@ const command$4 = {
     async prepare (args) {
         const workspace = await loadWorkspace(args);
         // Extract arguments
-        const rest = args._.map((arg)=>arg.toString());
+        let rest = args._;
         if (rest[0] === 'exec') {
             rest.splice(0, 1);
         }
         // Run script in workspace
-        return await workspace.exec(args.command, rest, {
+        rest = rest.map((arg)=>escapeCommandLineArg(arg.toString()));
+        return await workspace.exec([
+            args.command,
+            ...rest
+        ].join(' '), {
             buildScript: args.buildScript,
             buildDeps: args.depsMode
         });
     },
     async execute (args, arg) {
+        const logger = inject$(LOGGER);
         const job = arg;
         if (job.dependencies().length > 0) {
             const dependencies = pipe$(job.dependencies(), collect$(parallelFlow$({
@@ -1333,17 +1323,14 @@ const command$4 = {
                 return;
             }
         } else {
-            const logger = inject$(LOGGER);
             logger.verbose('No dependency to build');
         }
         await startSpan({
             op: 'subprocess',
-            name: [
-                job.cmd,
-                ...job.args
-            ].join(' ')
+            name: job.cmd
         }, async ()=>{
-            const child = spawn(job.cmd, job.args, {
+            logger.verbose(`spawn "${job.cmd}"`);
+            const child = spawn(job.cmd, {
                 stdio: 'inherit',
                 cwd: job.cwd,
                 env: {
@@ -1627,7 +1614,7 @@ const command$1 = {
     }
 };
 
-var version = "3.0.0-alpha.10";
+var version = "3.0.0-alpha.11";
 
 // Utils
 function dynamicImport(filepath) {
@@ -1802,7 +1789,7 @@ const logFormat = qwrap(chalkTemplateStderr).fun`#?:${qprop('label')}{grey [${q$
             const logGateway = inject$(LogGateway);
             flow$(inject$(LOGGER), filter$((log)=>log.level >= logLevel), logDelay$(), logGateway);
             logGateway.connect('console', toStderr(logFormat));
-        }));
+        }), true);
 }
 // Utils
 const VERBOSITY_LEVEL = {
@@ -1843,47 +1830,19 @@ function command(module) {
         });
 }
 
-function jobCommandPlan(module, job$) {
-    if ('prepare' in module) {
-        const prepare = trace(module.prepare, {
-            name: commandName(module),
-            op: 'cli.prepare'
-        });
-        return command({
-            ...module,
-            builder (base) {
-                const parser = withPlanMode(base);
-                if (module.builder) {
-                    return module.builder(parser);
-                } else {
-                    return parser;
-                }
-            },
-            async handler (args) {
-                job$.mutate(await prepare(args) ?? null);
-            }
-        });
-    } else {
-        return command({
-            ...module,
-            handler: ()=>undefined
-        });
-    }
-}
-// Utils
-function withPlanMode(parser) {
+function withPlan(parser) {
     return parser.option('plan', {
         type: 'boolean',
         default: false,
         describe: 'Only prints tasks to be run'
-    }).option('plan-mode', {
+    }).option('plan-format', {
         type: 'string',
-        desc: 'Plan output mode',
+        desc: 'Plan output format',
         choices: [
             'json',
-            'list'
+            'tree'
         ],
-        default: 'list'
+        default: 'tree'
     });
 }
 
@@ -1899,7 +1858,7 @@ function jobCommandExecute(module) {
     return command({
         ...module,
         builder (base) {
-            const parser = withPlanMode(base);
+            const parser = withPlan(base);
             if (module.builder) {
                 return module.builder(parser);
             } else {
@@ -1915,8 +1874,21 @@ function jobCommandExecute(module) {
                 return;
             }
             if (args.plan) {
-                const { jobPlan } = await traceImport('printPlan', ()=>import('./job-plan.js'));
-                jobPlan(job);
+                switch(args.planFormat){
+                    case 'json':
+                        {
+                            const { jobPlanJson } = await traceImport('printPlanJson', ()=>import('./job-plan.json.js'));
+                            jobPlanJson(job);
+                            break;
+                        }
+                    case 'tree':
+                    default:
+                        {
+                            const { jobPlan } = await traceImport('printPlan', ()=>import('./job-plan.js'));
+                            jobPlan(job);
+                            break;
+                        }
+                }
             } else {
                 if (execute) {
                     await execute(args, job);
@@ -1973,5 +1945,5 @@ void startSpan({
     }
 });
 
-export { CWD as C, LOGGER as L, SCHEDULER as S, ConfigService as a, cliParser as b, capitalize as c, command$5 as d, command$4 as e, command$3 as f, command$2 as g, command$1 as h, instrument as i, jobCommandPlan as j, logFormat as l };
+export { CWD as C, LOGGER as L, SCHEDULER as S, commandName as a, command as b, capitalize as c, ConfigService as d, cliParser as e, command$5 as f, command$4 as g, command$3 as h, command$2 as i, command$1 as j, instrument as k, logFormat as l, printJson as p, trace as t, withPlan as w };
 //# sourceMappingURL=main.js.map