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

package/dist/parser.js

@@ -1,30 +1,88 @@
-import { TaskManager, plan, SpawnTask, GroupTask, TaskSet, ParallelGroup, FallbackGroup, SequenceGroup } from '@jujulego/tasks';
+;{try{(function(){var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="870e33b2-51a5-4b3d-aff5-43027ce19814",e._sentryDebugIdIdentifier="sentry-dbid-870e33b2-51a5-4b3d-aff5-43027ce19814");})();}catch(e){}};!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{};e.SENTRY_RELEASE={id:"3.0.0-alpha.3"};}catch(e){}}();import { TaskManager, plan, SpawnTask, GroupTask, TaskSet, ParallelGroup, FallbackGroup, SequenceGroup } from '@jujulego/tasks';
 import { token$, inject$, asyncScope$ } from '@kyrielle/injector';
-import { 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 { pipe$, waitFor$, filter$, observable$, off$, once$, map$, collect$, asyncIterator$, var$, flow$ } from 'kyrielle';
+import { logger$, withTimestamp, withLabel, qLogDelay, LogLevel, LogGateway, logDelay$, toStderr } from '@kyrielle/logger';
+import { startSpan, getActiveSpan, updateSpanName, getRootSpan, startInactiveSpan } from '@sentry/node';
 import path from 'node:path';
-import { 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 { satisfies, compare, parse } from 'semver';
 import slugify from 'slugify';
 import yargs from 'yargs';
-import { hideBin } from 'yargs/helpers';
+import fs from 'node:fs';
 import { PathScurry } from 'path-scurry';
-import { qjson, defineQuickFormat, qprop, q$, qerror, qarg, qwrap } from '@jujulego/quick-tag';
+import { _ } from '@swc/helpers/_/_apply_decs_2203_r';
+import { Glob } from 'glob';
+import normalize from 'normalize-package-data';
+import moo from 'moo';
+import { qjson, qprop, q$, defineQuickFormat, qerror, qarg, qwrap } from '@jujulego/quick-tag';
 import Ajv from 'ajv';
 import os from 'node:os';
 import { cosmiconfig, defaultLoaders } from 'cosmiconfig';
 import { chalkTemplateStderr } from 'chalk-template';
 
-var version = "3.0.0-alpha.2";
+var version = "3.0.0-alpha.3";
+
+function trace(fun, opts) {
+    const name = typeof opts === 'string' ? opts : opts.name;
+    const use = typeof opts === 'object' ? opts.use : (_, r)=>r;
+    return function(...args) {
+        return pipe$(startSpan({
+            name
+        }, ()=>fun.call(this, ...args)), (r)=>use(name, r));
+    };
+}
+function instrument(opts) {
+    return (target, context)=>{
+        const name = typeof opts === 'string' ? opts : opts?.name ?? context.name.toString();
+        const use = typeof opts === 'object' ? opts.use : (_, r)=>r;
+        return trace(target, {
+            name,
+            use
+        });
+    };
+}
+function traceAsyncGenerator(name, generator) {
+    const instrumented = {
+        ...generator,
+        next: async ()=>startSpan({
+                name,
+                op: 'iterator.next'
+            }, ()=>generator.next()),
+        [Symbol.asyncIterator]: ()=>instrumented
+    };
+    return instrumented;
+}
+function traceLoad(name, loader) {
+    return startSpan({
+        name: `load ${name}`,
+        op: 'import'
+    }, loader);
+}
 
 function command$5(module) {
-    return (parser)=>parser.command(module);
+    const name = getCommandName(module);
+    const handler = trace(module.handler, 'cli.handler');
+    return (parser)=>parser.command({
+            ...module,
+            async handler (args) {
+                const activeSpan = getActiveSpan();
+                if (activeSpan) {
+                    updateSpanName(getRootSpan(activeSpan), `jill ${name}`);
+                }
+                await handler(args);
+            }
+        });
+}
+function getCommandName(module) {
+    if (!module.command) {
+        return '[unknown]';
+    }
+    if (typeof module.command === 'string') {
+        return module.command;
+    }
+    return module.command[0];
 }
 
 // Tokens
@@ -38,10 +96,45 @@ const PATH_SCURRY = token$('PathScurry', ()=>new PathScurry('/', {
         fs
     }));
 const TASK_MANAGER = token$('TaskManager', async ()=>{
-    return new TaskManager({
+    const manager = new TaskManager({
         jobs: (await inject$(CONFIG, asyncScope$())).jobs,
         logger: inject$(LOGGER)
     });
+    let rootSpan = getActiveSpan();
+    if (rootSpan) rootSpan = getRootSpan(rootSpan);
+    const spans = new Map();
+    manager.events$.on('added', (task)=>{
+        // Main span
+        const span = startInactiveSpan({
+            name: task.name,
+            parentSpan: (task.group && spans.get(task.group.id)) ?? rootSpan,
+            op: 'task'
+        });
+        task.events$.on('completed', ({ status })=>{
+            span.setStatus({
+                code: status === 'done' ? 1 : 2
+            });
+            span.end();
+        });
+        spans.set(task.id, span);
+        // Status spans
+        let statusSpan = startInactiveSpan({
+            name: task.status,
+            parentSpan: span,
+            op: 'task.status'
+        });
+        task.events$.on('status', ({ status })=>{
+            statusSpan.end();
+            if (!task.completed) {
+                statusSpan = startInactiveSpan({
+                    name: status,
+                    parentSpan: span,
+                    op: 'task.status'
+                });
+            }
+        });
+    });
+    return manager;
 });
 
 // Utils
@@ -55,13 +148,14 @@ function printJson(data, stream = process.stdout) {
 
 // Utils
 function executeCommand(module) {
-    const { prepare, execute, ...rest } = module;
+    const prepare = trace(module.prepare, 'cli.prepare');
+    const execute = module.execute && trace(module.execute, 'cli.execute');
     return command$5({
-        ...rest,
+        ...module,
         builder (base) {
             const parser = withPlanMode(base);
-            if (rest.builder) {
-                return rest.builder(parser);
+            if (module.builder) {
+                return module.builder(parser);
             } else {
                 return parser;
             }
@@ -72,7 +166,7 @@ function executeCommand(module) {
                 if (args.planMode === 'json') {
                     printJson(Array.from(plan(tasks)));
                 } else {
-                    const { default: TaskPlanInk } = await import('./task-plan.ink.js');
+                    const { default: TaskPlanInk } = await traceLoad('TaskPlanInk', ()=>import('./task-plan.ink.js'));
                     await TaskPlanInk({
                         tasks
                     });
@@ -81,7 +175,7 @@ function executeCommand(module) {
                 if (execute) {
                     await execute(args, tasks);
                 } else if (tasks.tasks.length > 0) {
-                    const { default: TaskExecInk } = await import('./task-exec.ink.js');
+                    const { default: TaskExecInk } = await traceLoad('TaskExecInk', ()=>import('./task-exec.ink.js'));
                     await TaskExecInk({
                         tasks,
                         verbose: [
@@ -100,13 +194,13 @@ function executeCommand(module) {
 }
 function planCommand(module, tasks$) {
     if ('prepare' in module) {
-        const { prepare, ...rest } = module;
+        const prepare = trace(module.prepare, 'cli.prepare');
         return command$5({
-            ...rest,
+            ...module,
             builder (base) {
                 const parser = withPlanMode(base);
-                if (rest.builder) {
-                    return rest.builder(parser);
+                if (module.builder) {
+                    return module.builder(parser);
                 } else {
                     return parser;
                 }
@@ -189,9 +283,30 @@ function streamLines$(task, stream = 'stdout') {
     });
 }
 
+var _dec$4, _dec1$3, _dec2$1, _initProto$4;
+_dec$4 = instrument('GitService.isAffected'), _dec1$3 = instrument('GitService.listBranches'), _dec2$1 = instrument('GitService.listTags');
 class GitService {
+    static{
+        ({ e: [_initProto$4] } = _(this, [
+            [
+                _dec$4,
+                2,
+                "isAffected"
+            ],
+            [
+                _dec1$3,
+                2,
+                "listBranches"
+            ],
+            [
+                _dec2$1,
+                2,
+                "listTags"
+            ]
+        ], []));
+    }
     // Attributes
-    _manager = inject$(TASK_MANAGER);
+    _manager = (_initProto$4(this), inject$(TASK_MANAGER));
     _logger = inject$(LOGGER);
     // Methods
     /**
@@ -431,6 +546,13 @@ function isCommandCtx(ctx) {
     return 'workspace' in ctx && 'command' in ctx;
 }
 
+class ClientError extends Error {
+    name = 'ClientError';
+    constructor(message){
+        super(message);
+    }
+}
+
 // Utils
 function capitalize(txt) {
     return txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase();
@@ -518,7 +640,7 @@ class ScriptTask extends GroupTask {
         // 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}`);
+            throw new ScriptNotFound(`No script ${this.script} in ${this.workspace.name}`);
         }
         // Prepare hooks run
         if (this._runHooks) {
@@ -594,12 +716,37 @@ class ScriptTask extends GroupTask {
 function isScriptCtx(ctx) {
     return 'workspace' in ctx && 'script' in ctx;
 }
+class ScriptNotFound extends ClientError {
+    name = 'ScriptNotFound';
+}
 
+var _dec$3, _dec1$2, _initProto$3;
+_dec$3 = instrument({
+    name: 'Workspace.dependencies',
+    use: traceAsyncGenerator
+}), _dec1$2 = instrument({
+    name: 'Workspace.devDependencies',
+    use: traceAsyncGenerator
+});
 class Workspace {
     manifest;
     project;
+    static{
+        ({ e: [_initProto$3] } = _(this, [
+            [
+                _dec$3,
+                2,
+                "dependencies"
+            ],
+            [
+                _dec1$2,
+                2,
+                "devDependencies"
+            ]
+        ], []));
+    }
     // Attributes
-    _affectedCache = new Map();
+    _affectedCache = (_initProto$3(this), new Map());
     _logger;
     _git = inject$(GitService);
     _root;
@@ -755,9 +902,43 @@ class Workspace {
     }
 }
 
+var _dec$2, _dec1$1, _dec2, _dec3, _dec4, _initProto$2;
+_dec$2 = instrument('Project.currentWorkspace'), _dec1$1 = instrument('Project.mainWorkspace'), _dec2 = instrument('Project.packageManager'), _dec3 = instrument('Project.workspace'), _dec4 = instrument({
+    name: 'Project.workspaces',
+    use: traceAsyncGenerator
+});
 class Project {
+    static{
+        ({ e: [_initProto$2] } = _(this, [
+            [
+                _dec$2,
+                2,
+                "currentWorkspace"
+            ],
+            [
+                _dec1$1,
+                2,
+                "mainWorkspace"
+            ],
+            [
+                _dec2,
+                2,
+                "packageManager"
+            ],
+            [
+                _dec3,
+                2,
+                "workspace"
+            ],
+            [
+                _dec4,
+                2,
+                "workspaces"
+            ]
+        ], []));
+    }
     // Attributes
-    _isFullyLoaded = false;
+    _isFullyLoaded = (_initProto$2(this), false);
     _lock = mutex$();
     _mainWorkspace;
     _packageManager;
@@ -895,11 +1076,22 @@ class Project {
     }
 }
 
+var _dec$1, _initProto$1;
+_dec$1 = instrument();
 /**
  * Helps detecting projects folders
  */ class ProjectsRepository {
+    static{
+        ({ e: [_initProto$1] } = _(this, [
+            [
+                _dec$1,
+                2,
+                "searchProjectRoot"
+            ]
+        ], []));
+    }
     // Attributes
-    _cache = new Map();
+    _cache = (_initProto$1(this), new Map());
     _logger = inject$(LOGGER).child(withLabel('projects'));
     _scurry = inject$(PATH_SCURRY);
     // Methods
@@ -973,11 +1165,14 @@ const LOCK_FILES = [
         ],
         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);
-    });
+    }).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.
@@ -988,15 +1183,33 @@ const LOCK_FILES = [
     });
 }
 
-class TaskExpressionError extends Error {
+class TaskExpressionError extends ClientError {
+    name = 'TaskExpressionError';
 }
-class TaskSyntaxError extends Error {
+class TaskSyntaxError extends ClientError {
+    name = 'TaskSyntaxError';
 }
 
+var _dec, _dec1, _initProto;
+_dec = instrument('TaskParserService.parse'), _dec1 = instrument('TaskParserService.buildTask');
 // Service
 class TaskParserService {
+    static{
+        ({ e: [_initProto] } = _(this, [
+            [
+                _dec,
+                2,
+                "parse"
+            ],
+            [
+                _dec1,
+                2,
+                "buildTask"
+            ]
+        ], []));
+    }
     // Attributes
-    _logger = inject$(LOGGER).child(withLabel('task-parser'));
+    _logger = (_initProto(this), inject$(LOGGER).child(withLabel('task-parser')));
     // Statics
     static isTaskNode(node) {
         return 'script' in node;
@@ -1342,10 +1555,16 @@ const command$4 = {
         workspace = await project.mainWorkspace();
     }
     if (!workspace) {
-        throw new Error(`Workspace "${args.workspace || '.'}" not found`);
+        throw new WorkspaceNotFound(args.workspace || '.');
     }
     return workspace;
 }
+class WorkspaceNotFound extends ClientError {
+    name = 'WorkspaceNotFound';
+    constructor(workspace){
+        super(`Workspace "${workspace}" not found`);
+    }
+}
 
 // Command
 const command$3 = {
@@ -1397,7 +1616,7 @@ const command$3 = {
                 dependencies.add(dep);
             }
             // Run dependencies first with spinners
-            const { default: TaskExecInk } = await import('./task-exec.ink.js');
+            const { default: TaskExecInk } = await traceLoad('TaskExecInk', ()=>import('./task-exec.ink.js'));
             await TaskExecInk({
                 tasks: dependencies,
                 verbose: [
@@ -1544,7 +1763,7 @@ const command$2 = {
             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(', ')}.`);
+                    throw new ClientError(`Cannot sort by non printed attributes. Missing ${miss.join(', ')}.`);
                 }
             }
             if (!argv['sort-by']?.length && argv.attribute.length > 0) {
@@ -1584,7 +1803,7 @@ const command$2 = {
                     data.root = path.relative(process.cwd(), data.root) || '.';
                 }
             }
-            const { default: ListInk } = await import('./list.ink.js');
+            const { default: ListInk } = await traceLoad('ListInk', ()=>import('./list.ink.js'));
             await ListInk({
                 attributes: args.attribute,
                 headers: args.headers,
@@ -1678,7 +1897,7 @@ const command = {
     builder: withWorkspace,
     async handler (args) {
         const workspace = await loadWorkspace(args);
-        const { default: TreeInk } = await import('./tree.ink.js');
+        const { default: TreeInk } = await traceLoad('TreeInk', ()=>import('./tree.ink.js'));
         await TreeInk({
             workspace
         });
@@ -1686,7 +1905,7 @@ const command = {
 };
 
 // Utils
-async function dynamicImport(filepath) {
+function dynamicImport(filepath) {
     return import(/* webpackIgnore: true */ process.platform === 'win32' ? `file://${filepath}` : filepath);
 }
 
@@ -1814,19 +2033,22 @@ var config_service = /*#__PURE__*/Object.freeze({
 });
 
 // Middleware
-function configMiddleware(parser) {
+function withConfig(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();
-        }
-    });
+    }).middleware((args)=>startSpan({
+            name: 'config',
+            op: 'cli.middleware'
+        }, async ()=>{
+            const configService = inject$(ConfigService, asyncScope$());
+            if (args.configFile) {
+                await configService.loadConfig(args.configFile);
+            } else {
+                await configService.searchConfig();
+            }
+        }));
 }
 
 const LEVEL_COLORS = {
@@ -1845,24 +2067,27 @@ const VERBOSITY_LEVEL = {
     2: 'debug'
 };
 // Middleware
-function loggerMiddleware(parser) {
+function withLogger(parser) {
     return parser.option('verbose', {
         alias: 'v',
         default: 'info',
         type: 'count',
         description: 'Set verbosity level',
         coerce: (cnt)=>VERBOSITY_LEVEL[Math.min(cnt, 2)]
-    }).middleware((args)=>{
-        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));
-    });
+    }).middleware((args)=>startSpan({
+            name: 'logger',
+            op: 'cli.middleware'
+        }, ()=>{
+            const logLevel = args.verbose ? LogLevel[args.verbose] : LogLevel.info;
+            const logGateway = inject$(LogGateway);
+            flow$(inject$(LOGGER), filter$((log)=>log.level >= logLevel), logDelay$(), logGateway);
+            logGateway.connect('console', toStderr(logFormat));
+        }));
 }
 
 // Utils
 function baseParser() {
-    return pipe$(yargs(hideBin(process$1.argv)).scriptName('jill').version(version).demandCommand().recommendCommands(), loggerMiddleware, configMiddleware);
+    return pipe$(yargs().scriptName('jill').version(version).demandCommand().recommendCommands(), withLogger, withConfig);
 }
 /**
  * Prepare parser executing commands
@@ -1875,5 +2100,5 @@ function baseParser() {
     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 };
+export { ClientError as C, LOGGER as L, ScriptTask as S, TASK_MANAGER as T, isScriptCtx as a, CommandTask as b, capitalize as c, CWD as d, executeParser as e, ConfigService as f, instrument as g, isCommandCtx as i, logFormat as l, planParser as p };
 //# sourceMappingURL=parser.js.map