@noego/captain 1.0.0 → 1.0.2

package/dist/components/cli.js

@@ -2,19 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLI = void 0;
 const commander_1 = require("commander");
+const trace_1 = require("@noego/trace");
+const packageJson = require('../../package.json');
 class CLI {
     constructor(logger, parser, scheduler, executor) {
         this.logger = logger;
         this.parser = parser;
         this.scheduler = scheduler;
         this.executor = executor;
+        this.trace = (0, trace_1.getTrace)('CLI');
         this.program = new commander_1.Command();
     }
     setup() {
         this.program
             .name('captain')
             .description('YAML-driven task runner for TypeScript')
-            .version('1.0.0')
+            .version(packageJson.version)
             .argument('[files...]', 'YAML task files to process')
             .option('-r, --run <task>', 'Run a specific task immediately')
             .option('-l, --list', 'List all tasks without running them')
@@ -24,10 +27,17 @@ class CLI {
         });
     }
     async processFiles(files, options) {
+        this.trace.info('cli.process.started', {
+            fileCount: files.length,
+            selectedMode: options.list ? 'list' : options.run ? 'run' : 'schedule',
+            requestedTask: options.run
+        });
         if (files.length === 0) {
+            this.trace.warn('cli.process.skipped', {
+                reason: 'missing_files'
+            });
             this.logger.error('No task files specified');
             this.program.help();
-            return;
         }
         // Parse all files
         const allTasks = {};
@@ -45,25 +55,45 @@ class CLI {
                 }
             }
             catch (error) {
+                this.trace.error('cli.file.failed', {
+                    file,
+                    error: error instanceof Error ? error.message : String(error)
+                });
                 this.logger.error(`Error processing file ${file}: ${error}`);
             }
         }
         // Handle list option
         if (options.list) {
             this.listTasks(allTasks);
+            this.trace.info('cli.process.completed', {
+                selectedMode: 'list',
+                taskCount: Object.keys(allTasks).length
+            });
             return;
         }
         // Handle run option
         if (options.run) {
             await this.runSingleTask(options.run, allTasks);
+            this.trace.info('cli.process.completed', {
+                selectedMode: 'run',
+                taskCount: Object.keys(allTasks).length,
+                requestedTask: options.run
+            });
             return;
         }
         // Schedule all tasks
         this.scheduleTasks(allTasks);
+        this.trace.info('cli.process.completed', {
+            selectedMode: 'schedule',
+            taskCount: Object.keys(allTasks).length
+        });
         // Keep the process running
         this.logger.info('Captain is running. Press Ctrl+C to exit.');
     }
     listTasks(tasks) {
+        this.trace.info('cli.tasks.list.started', {
+            taskCount: Object.keys(tasks).length
+        });
         this.logger.info('Available tasks:');
         Object.entries(tasks).forEach(([name, task]) => {
             this.logger.info(`- ${name}: ${task.description || 'No description'}`);
@@ -71,25 +101,45 @@ class CLI {
             this.logger.info(`  File: ${task.file}`);
             this.logger.info('');
         });
+        this.trace.info('cli.tasks.list.completed', {
+            taskCount: Object.keys(tasks).length
+        });
     }
     async runSingleTask(taskName, tasks) {
         const task = tasks[taskName];
         if (!task) {
+            this.trace.warn('cli.task.run.skipped', {
+                taskName,
+                reason: 'not_found'
+            });
             this.logger.error(`Task "${taskName}" not found`);
             return;
         }
+        this.trace.info('cli.task.run.started', { taskName });
         this.logger.info(`Running task ${taskName} immediately`);
-        await this.executor.executeTask(taskName, task);
+        const success = await this.executor.executeTask(taskName, task);
+        this.trace.info('cli.task.run.completed', { taskName, success });
         this.logger.info('Task execution complete');
     }
     scheduleTasks(tasks) {
+        let validCount = 0;
+        let scheduledCount = 0;
         Object.entries(tasks).forEach(([name, task]) => {
             if (this.parser.validateTask(name, task)) {
-                this.scheduler.scheduleTask(name, task, async () => {
+                validCount += 1;
+                const scheduled = this.scheduler.scheduleTask(name, task, async () => {
                     await this.executor.executeTask(name, task);
                 });
+                if (scheduled) {
+                    scheduledCount += 1;
+                }
             }
         });
+        this.trace.info('cli.tasks.schedule.completed', {
+            taskCount: Object.keys(tasks).length,
+            validCount,
+            scheduledCount
+        });
         this.logger.info(`Scheduled ${Object.keys(tasks).length} tasks`);
     }
     parse(argv) {

package/dist/components/executor.js

@@ -36,15 +36,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Executor = void 0;
 const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
+const trace_1 = require("@noego/trace");
 class Executor {
     constructor(logger) {
         this.logger = logger;
         this.runningTasks = new Map();
+        this.trace = (0, trace_1.getTrace)('Executor');
     }
     async executeTask(taskName, taskDef) {
         try {
+            this.trace.info('executor.task.started', {
+                taskName,
+                targetType: taskDef.file ? 'file' : taskDef.command ? 'command' : 'none',
+                timeoutSeconds: taskDef.timeout,
+                maxConcurrency: taskDef.concurrency?.max || 1,
+                allowOverlap: taskDef.concurrency?.allow_overlap
+            });
             // Check concurrency limits
-            if (!this.checkConcurrency(taskName, taskDef)) {
+            const concurrency = this.checkConcurrency(taskName, taskDef);
+            if (!concurrency.allowed) {
+                this.trace.warn('executor.task.skipped', {
+                    taskName,
+                    reason: concurrency.reason,
+                    runningCount: concurrency.runningCount,
+                    maxConcurrency: concurrency.maxConcurrency
+                });
                 return false;
             }
             const env = { ...process.env, ...taskDef.env };
@@ -52,6 +68,11 @@ class Executor {
             if (taskDef.file) {
                 // Execute TypeScript/JavaScript file using tsx
                 const filePath = path.resolve(process.cwd(), taskDef.file);
+                this.trace.info('executor.task.spawned', {
+                    taskName,
+                    targetType: 'file',
+                    filePath
+                });
                 this.logger.info(`Executing task ${taskName}: ${filePath}`);
                 childProcess = (0, child_process_1.spawn)('npx', ['tsx', filePath], {
                     env,
@@ -61,6 +82,12 @@ class Executor {
             else if (taskDef.command) {
                 // Execute shell command using user's shell
                 const shell = process.env.SHELL || '/bin/sh';
+                this.trace.info('executor.task.spawned', {
+                    taskName,
+                    targetType: 'command',
+                    shell,
+                    commandLength: taskDef.command.length
+                });
                 this.logger.info(`Executing task ${taskName}: ${taskDef.command}`);
                 childProcess = (0, child_process_1.spawn)(shell, ['-c', taskDef.command], {
                     env,
@@ -68,6 +95,10 @@ class Executor {
                 });
             }
             else {
+                this.trace.warn('executor.task.skipped', {
+                    taskName,
+                    reason: 'missing_target'
+                });
                 this.logger.error(`Task ${taskName} has no file or command`);
                 return false;
             }
@@ -80,6 +111,10 @@ class Executor {
             // Set timeout if specified
             if (taskDef.timeout) {
                 execution.timeout = setTimeout(() => {
+                    this.trace.warn('executor.task.timed_out', {
+                        taskName,
+                        timeoutSeconds: taskDef.timeout
+                    });
                     this.logger.warn(`Task ${taskName} timed out after ${taskDef.timeout}s`);
                     childProcess.kill();
                 }, taskDef.timeout * 1000);
@@ -90,10 +125,18 @@ class Executor {
             this.runningTasks.set(taskName, runningTasks);
             // Handle stdout
             childProcess.stdout.on('data', (data) => {
+                this.trace.debug('executor.task.stdout', {
+                    taskName,
+                    outputLength: data.toString().trim().length
+                });
                 this.logger.info(`[${taskName}] ${data.toString().trim()}`);
             });
             // Handle stderr
             childProcess.stderr.on('data', (data) => {
+                this.trace.debug('executor.task.stderr', {
+                    taskName,
+                    outputLength: data.toString().trim().length
+                });
                 this.logger.error(`[${taskName}] ${data.toString().trim()}`);
             });
             // Handle process completion
@@ -108,9 +151,19 @@ class Executor {
                     const success = code === 0;
                     const duration = (new Date().getTime() - execution.startTime.getTime()) / 1000;
                     if (success) {
+                        this.trace.info('executor.task.completed', {
+                            taskName,
+                            exitCode: code,
+                            durationSeconds: duration
+                        });
                         this.logger.info(`Task ${taskName} completed successfully in ${duration}s`);
                     }
                     else {
+                        this.trace.error('executor.task.failed', {
+                            taskName,
+                            exitCode: code,
+                            durationSeconds: duration
+                        });
                         this.logger.error(`Task ${taskName} failed with exit code ${code} after ${duration}s`);
                         // Implement retry logic here if needed
                     }
@@ -119,6 +172,10 @@ class Executor {
             });
         }
         catch (error) {
+            this.trace.error('executor.task.failed', {
+                taskName,
+                error: error instanceof Error ? error.message : String(error)
+            });
             this.logger.error(`Failed to execute task ${taskName}: ${error}`);
             return false;
         }
@@ -129,14 +186,28 @@ class Executor {
         // Check if max concurrency would be exceeded
         if (runningTasks.length >= maxConcurrency) {
             this.logger.warn(`Task ${taskName} reached max concurrency (${maxConcurrency})`);
-            return false;
+            return {
+                allowed: false,
+                maxConcurrency,
+                reason: 'max_concurrency',
+                runningCount: runningTasks.length
+            };
         }
         // Check if overlap is allowed
         if (runningTasks.length > 0 && taskDef.concurrency?.allow_overlap === false) {
             this.logger.warn(`Task ${taskName} is already running and overlap is not allowed`);
-            return false;
+            return {
+                allowed: false,
+                maxConcurrency,
+                reason: 'overlap_disallowed',
+                runningCount: runningTasks.length
+            };
         }
-        return true;
+        return {
+            allowed: true,
+            maxConcurrency,
+            runningCount: runningTasks.length
+        };
     }
     removeRunningTask(taskName, execution) {
         const runningTasks = this.runningTasks.get(taskName) || [];

package/dist/components/parser.js

@@ -6,12 +6,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
 const promises_1 = __importDefault(require("fs/promises"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
+const trace_1 = require("@noego/trace");
 class Parser {
     constructor(logger) {
         this.logger = logger;
+        this.trace = (0, trace_1.getTrace)('Parser');
     }
     async parseFile(filePath) {
         try {
+            this.trace.info('parser.parse.started', { filePath });
             this.logger.debug(`Parsing file: ${filePath}`);
             // Read file
             const fileContents = await promises_1.default.readFile(filePath, 'utf8');
@@ -21,10 +24,16 @@ class Parser {
             if (!parsedData.tasks) {
                 throw new Error(`Invalid task file: ${filePath}. No tasks defined.`);
             }
-            this.logger.info(`Parsed ${Object.keys(parsedData.tasks).length} tasks from ${filePath}`);
+            const taskCount = Object.keys(parsedData.tasks).length;
+            this.trace.info('parser.parse.completed', { filePath, taskCount });
+            this.logger.info(`Parsed ${taskCount} tasks from ${filePath}`);
             return parsedData;
         }
         catch (error) {
+            this.trace.error('parser.parse.failed', {
+                filePath,
+                error: error instanceof Error ? error.message : String(error)
+            });
             this.logger.error(`Failed to parse file ${filePath}: ${error}`);
             throw error;
         }
@@ -32,17 +41,33 @@ class Parser {
     validateTask(taskName, task) {
         // Check required fields
         if (!task.schedule) {
+            this.trace.warn('parser.task.validation.failed', {
+                taskName,
+                reason: 'missing_schedule'
+            });
             this.logger.error(`Task ${taskName} is missing required field: schedule`);
             return false;
         }
         if (!task.file && !task.command) {
+            this.trace.warn('parser.task.validation.failed', {
+                taskName,
+                reason: 'missing_target'
+            });
             this.logger.error(`Task ${taskName} must have either 'file' or 'command'`);
             return false;
         }
         if (task.file && task.command) {
+            this.trace.warn('parser.task.validation.failed', {
+                taskName,
+                reason: 'multiple_targets'
+            });
             this.logger.error(`Task ${taskName} cannot have both 'file' and 'command'`);
             return false;
         }
+        this.trace.info('parser.task.validation.completed', {
+            taskName,
+            targetType: task.file ? 'file' : 'command'
+        });
         return true;
     }
 }

package/dist/components/scheduler.js

@@ -35,34 +35,60 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scheduler = void 0;
 const cron = __importStar(require("node-cron"));
+const trace_1 = require("@noego/trace");
 class Scheduler {
     constructor(logger) {
         this.logger = logger;
         this.schedules = new Map();
+        this.trace = (0, trace_1.getTrace)('Scheduler');
     }
     scheduleTask(taskName, taskDef, callback) {
         try {
+            this.trace.info('scheduler.task.schedule.started', {
+                taskName,
+                schedule: taskDef.schedule
+            });
             // Validate cron expression
             if (!cron.validate(taskDef.schedule)) {
+                this.trace.warn('scheduler.task.schedule.skipped', {
+                    taskName,
+                    schedule: taskDef.schedule,
+                    reason: 'invalid_cron'
+                });
                 this.logger.error(`Invalid cron schedule for task ${taskName}: ${taskDef.schedule}`);
                 return false;
             }
             // Schedule the task
             const scheduledTask = cron.schedule(taskDef.schedule, async () => {
+                this.trace.info('scheduler.task.triggered', { taskName });
                 this.logger.info(`Running scheduled task: ${taskName}`);
                 try {
                     await callback();
+                    this.trace.info('scheduler.task.completed', { taskName });
                 }
                 catch (error) {
+                    this.trace.error('scheduler.task.failed', {
+                        taskName,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
                     this.logger.error(`Error in scheduled task ${taskName}: ${error}`);
                 }
             });
             // Store the scheduled task
             this.schedules.set(taskName, scheduledTask);
+            this.trace.info('scheduler.task.schedule.completed', {
+                taskName,
+                schedule: taskDef.schedule
+            });
             this.logger.info(`Scheduled task ${taskName} with cron: ${taskDef.schedule}`);
             return true;
         }
         catch (error) {
+            this.trace.error('scheduler.task.schedule.failed', {
+                taskName,
+                schedule: taskDef.schedule,
+                error: error instanceof Error ? error.message : String(error)
+            });
             this.logger.error(`Failed to schedule task ${taskName}: ${error}`);
             return false;
         }
@@ -72,17 +98,27 @@ class Scheduler {
         if (scheduledTask) {
             scheduledTask.stop();
             this.schedules.delete(taskName);
+            this.trace.info('scheduler.task.stopped', { taskName });
             this.logger.info(`Stopped scheduled task: ${taskName}`);
             return true;
         }
+        this.trace.warn('scheduler.task.stop.skipped', {
+            taskName,
+            reason: 'not_found'
+        });
         return false;
     }
     stopAllTasks() {
+        this.trace.info('scheduler.tasks.stop_all.started', {
+            taskCount: this.schedules.size
+        });
         for (const [taskName, scheduledTask] of this.schedules.entries()) {
             scheduledTask.stop();
+            this.trace.info('scheduler.task.stopped', { taskName });
             this.logger.info(`Stopped scheduled task: ${taskName}`);
         }
         this.schedules.clear();
+        this.trace.info('scheduler.tasks.stop_all.completed');
     }
 }
 exports.Scheduler = Scheduler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noego/captain",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "YAML-driven task runner for TypeScript files",
   "main": "dist/index.js",
   "bin": {
@@ -31,12 +31,17 @@
   "author": "",
   "license": "ISC",
   "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "@noego/ioc": "^0.0.10",
+    "@noego/ioc": "^0.3.1",
+    "@noego/trace": "^0.0.4",
     "commander": "^13.1.0",
     "dotenv": "^16.5.0",
     "js-yaml": "^4.1.0",
     "node-cron": "^3.0.3",
+    "rxjs": "^7.8.2",
     "ts-node": "^10.9.2",
     "winston": "^3.17.0"
   },