@forgehive/forge-cli 0.2.14 → 0.3.0

package/dist/tasks/task/remove.js

@@ -25,29 +25,33 @@ const boundaries = {
         await promises_1.default.unlink(filePath);
     }
 };
-exports.remove = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName }, { loadConf, persistConf, deleteFile }) {
-    // Load shadow configuration
-    const forge = await loadConf({});
-    // Check if the task exists in shadow.json
-    if (!forge.tasks[descriptorName]) {
-        throw new Error(`Task '${descriptorName}' not found in forge.json`);
-    }
-    // Get the task file path
-    const taskFilePath = path_1.default.join(process.cwd(), forge.tasks[descriptorName].path);
-    console.log(`
+exports.remove = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ descriptorName }, { loadConf, persistConf, deleteFile }) {
+        // Load shadow configuration
+        const forge = await loadConf({});
+        // Check if the task exists in shadow.json
+        if (!forge.tasks[descriptorName]) {
+            throw new Error(`Task '${descriptorName}' not found in forge.json`);
+        }
+        // Get the task file path
+        const taskFilePath = path_1.default.join(process.cwd(), forge.tasks[descriptorName].path);
+        console.log(`
     ==================================================
     Removing task: ${descriptorName}
     File path: ${taskFilePath}
     ==================================================
     `);
-    // Delete the task file
-    await deleteFile(taskFilePath);
-    // Remove the task from shadow.json
-    delete forge.tasks[descriptorName];
-    // Save the updated shadow.json
-    await persistConf(forge);
-    return {
-        status: 'Ok',
-        message: `Task '${descriptorName}' has been successfully removed`
-    };
+        // Delete the task file
+        await deleteFile(taskFilePath);
+        // Remove the task from shadow.json
+        delete forge.tasks[descriptorName];
+        // Save the updated shadow.json
+        await persistConf(forge);
+        return {
+            status: 'Ok',
+            message: `Task '${descriptorName}' has been successfully removed`
+        };
+    }
 });

package/dist/tasks/task/replay.js

@@ -80,100 +80,104 @@ const boundaries = {
         }
     }
 };
-exports.replay = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName, path: fixturePath, cache }, { readFixture, loadConf, loadCurrentProfile, bundleCreate, bundleLoad, ensureBuildsFolder, verifyLogFolder, sendLogToAPI }) {
-    console.log('Input descriptorName:', descriptorName);
-    console.log('Input path:', fixturePath);
-    console.log('Input cache:', cache);
-    // Load forge configuration
-    const forge = await loadConf({});
-    const taskDescriptor = forge.tasks[descriptorName];
-    const projectName = forge.project.name;
-    if (taskDescriptor === undefined) {
-        throw new Error(`Task ${descriptorName} is not defined in forge.json`);
-    }
-    // Resolve the fixture path (check if absolute, if not make it relative to logs folder)
-    const resolvedFixturePath = path_1.default.isAbsolute(fixturePath)
-        ? fixturePath
-        : path_1.default.join(process.cwd(), forge.paths.fixtures, fixturePath);
-    // Read the file from the provided path
-    const fixture = await readFixture(resolvedFixturePath);
-    // Try to load profile, but continue if not found
-    let profile = null;
-    try {
-        profile = await loadCurrentProfile({});
-    }
-    catch (error) {
-        // Profile not found or not configured, continue without it
-        console.log('No profile found, logs will not be sent to remote API');
-    }
-    // Verify if log folder exists
-    const logFolderPath = path_1.default.join(process.cwd(), forge.paths.logs);
-    const logFolderExists = await verifyLogFolder(logFolderPath);
-    if (!logFolderExists) {
-        throw new Error(`Log folder "${logFolderPath}" does not exist`);
-    }
-    // Prepare paths
-    const entryPoint = path_1.default.join(process.cwd(), taskDescriptor.path);
-    const buildsPath = await ensureBuildsFolder();
-    const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
-    // Bundle the task
-    await bundleCreate({
-        entryPoint,
-        outputFile
-    });
-    // Load the bundled task
-    const bundle = await bundleLoad({
-        bundlePath: outputFile
-    });
-    // Get the task handler
-    const task = bundle[taskDescriptor.handler];
-    if (!task) {
-        throw new Error(`Handler "${taskDescriptor.handler}" not found in bundle`);
-    }
-    // Configure boundaries based on cache parameter if provided
-    const boundaryConfig = {};
-    if (cache) {
-        // Parse the comma-separated list and trim each item
-        const cacheBoundaries = cache.split(',').map((b) => b.trim());
-        // Log which boundaries will use cache mode
-        if (cacheBoundaries.length > 0) {
-            // Set each specified boundary to 'replay' mode
-            cacheBoundaries.forEach((boundary) => {
-                boundaryConfig[boundary] = 'replay';
-            });
+exports.replay = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ descriptorName, path: fixturePath, cache }, { readFixture, loadConf, loadCurrentProfile, bundleCreate, bundleLoad, ensureBuildsFolder, verifyLogFolder, sendLogToAPI }) {
+        console.log('Input descriptorName:', descriptorName);
+        console.log('Input path:', fixturePath);
+        console.log('Input cache:', cache);
+        // Load forge configuration
+        const forge = await loadConf({});
+        const taskDescriptor = forge.tasks[descriptorName];
+        const projectName = forge.project.name;
+        if (taskDescriptor === undefined) {
+            throw new Error(`Task ${descriptorName} is not defined in forge.json`);
         }
-    }
-    console.log('==================================================');
-    console.log('UUID:', fixture.fixtureUUID);
-    console.log('Task name:', fixture.taskName);
-    console.log('Project name:', fixture.projectName);
-    console.log('Context:', fixture.context);
-    console.log('==================================================');
-    console.log('Replay:', fixture.input);
-    console.log('Boundaries:', JSON.stringify(fixture.boundaries, null, 2));
-    console.log('==================================================');
-    console.log('Boundary config:', boundaryConfig);
-    console.log('==================================================');
-    // Perform the replay
-    const [result, error, record] = await task.safeReplay({
-        input: fixture.input,
-        output: fixture.output,
-        boundaries: fixture.boundaries,
-    }, {
-        boundaries: boundaryConfig // Use configured boundary modes
-    });
-    // Send the log to API if profile is available
-    if (profile) {
+        // Resolve the fixture path (check if absolute, if not make it relative to logs folder)
+        const resolvedFixturePath = path_1.default.isAbsolute(fixturePath)
+            ? fixturePath
+            : path_1.default.join(process.cwd(), forge.paths.fixtures, fixturePath);
+        // Read the file from the provided path
+        const fixture = await readFixture(resolvedFixturePath);
+        // Try to load profile, but continue if not found
+        let profile = null;
         try {
-            await sendLogToAPI(profile, projectName, descriptorName, record, fixture.fixtureUUID);
+            profile = await loadCurrentProfile({});
         }
-        catch (e) {
-            console.error('Failed to send log to API:', e);
+        catch (error) {
+            // Profile not found or not configured, continue without it
+            console.log('No profile found, logs will not be sent to remote API');
         }
+        // Verify if log folder exists
+        const logFolderPath = path_1.default.join(process.cwd(), forge.paths.logs);
+        const logFolderExists = await verifyLogFolder(logFolderPath);
+        if (!logFolderExists) {
+            throw new Error(`Log folder "${logFolderPath}" does not exist`);
+        }
+        // Prepare paths
+        const entryPoint = path_1.default.join(process.cwd(), taskDescriptor.path);
+        const buildsPath = await ensureBuildsFolder();
+        const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
+        // Bundle the task
+        await bundleCreate({
+            entryPoint,
+            outputFile
+        });
+        // Load the bundled task
+        const bundle = await bundleLoad({
+            bundlePath: outputFile
+        });
+        // Get the task handler
+        const task = bundle[taskDescriptor.handler];
+        if (!task) {
+            throw new Error(`Handler "${taskDescriptor.handler}" not found in bundle`);
+        }
+        // Configure boundaries based on cache parameter if provided
+        const boundaryConfig = {};
+        if (cache) {
+            // Parse the comma-separated list and trim each item
+            const cacheBoundaries = cache.split(',').map((b) => b.trim());
+            // Log which boundaries will use cache mode
+            if (cacheBoundaries.length > 0) {
+                // Set each specified boundary to 'replay' mode
+                cacheBoundaries.forEach((boundary) => {
+                    boundaryConfig[boundary] = 'replay';
+                });
+            }
+        }
+        console.log('==================================================');
+        console.log('UUID:', fixture.fixtureUUID);
+        console.log('Task name:', fixture.taskName);
+        console.log('Project name:', fixture.projectName);
+        console.log('Context:', fixture.context);
+        console.log('==================================================');
+        console.log('Replay:', fixture.input);
+        console.log('Boundaries:', JSON.stringify(fixture.boundaries, null, 2));
+        console.log('==================================================');
+        console.log('Boundary config:', boundaryConfig);
+        console.log('==================================================');
+        // Perform the replay
+        const [result, error, record] = await task.safeReplay({
+            input: fixture.input,
+            output: fixture.output,
+            boundaries: fixture.boundaries,
+        }, {
+            boundaries: boundaryConfig // Use configured boundary modes
+        });
+        // Send the log to API if profile is available
+        if (profile) {
+            try {
+                await sendLogToAPI(profile, projectName, descriptorName, record, fixture.fixtureUUID);
+            }
+            catch (e) {
+                console.error('Failed to send log to API:', e);
+            }
+        }
+        if (error) {
+            throw new Error(error.message);
+        }
+        return result;
     }
-    if (error) {
-        throw new Error(error.message);
-    }
-    return result;
 });
 exports.replay.setDescription(description);

package/dist/tasks/task/run.js

@@ -1,7 +1,8 @@
 "use strict";
 // TASK: run
 // Run this task with:
-// shadow-cli task:run
+// most recursive call on the project
+// forge task:run task:run
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -75,87 +76,91 @@ const boundaries = {
         }
     }
 };
-exports.run = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName, args }, { loadConf, bundleCreate, bundleLoad, verifyLogFolder, ensureBuildsFolder, loadCurrentProfile, sendLogToAPI }) {
-    // Load forge configuration
-    const forge = await loadConf({});
-    const taskDescriptor = forge.tasks[descriptorName];
-    const projectName = forge.project.name;
-    if (taskDescriptor === undefined) {
-        throw new Error('Task is not defined on forge.json');
-    }
-    // Try to load profile, but continue if not found
-    let profile = null;
-    try {
-        profile = await loadCurrentProfile({});
-    }
-    catch (error) {
-        // Profile not found or not configured, continue without it
-        console.log('No profile found, logs will not be sent to remote API');
-    }
-    // Verify if log folder exists
-    const logFolderPath = path_1.default.join(process.cwd(), forge.paths.logs);
-    const logFolderExists = await verifyLogFolder(logFolderPath);
-    if (!logFolderExists) {
-        throw new Error(`Log folder "${logFolderPath}" does not exist`);
-    }
-    // Prepare paths
-    const logsPath = path_1.default.join(logFolderPath, descriptorName);
-    const entryPoint = path_1.default.join(process.cwd(), taskDescriptor.path);
-    const buildsPath = await ensureBuildsFolder();
-    const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
-    // Bundle the task
-    await bundleCreate({
-        entryPoint,
-        outputFile
-    });
-    // Load the bundled task
-    const bundle = await bundleLoad({
-        bundlePath: outputFile
-    });
-    // Get the task handler
-    const task = bundle[taskDescriptor.handler];
-    if (!task) {
-        throw new Error(`Handler "${taskDescriptor.handler}" not found in bundle`);
-    }
-    // Setup record tape
-    let tape = new record_tape_1.RecordTape({
-        path: logsPath
-    });
-    // load record tape
-    try {
-        await tape.load();
-        // Need to figure out how to handle the log length
-        // and other options for the RecordTape
-        // For now, we'll just keep the implementation simple
-        const maxLogLength = 9;
-        const log = tape.getLog();
-        if (log.length > maxLogLength) {
-            const newTape = new record_tape_1.RecordTape({
-                path: logsPath,
-                log: log.slice(-maxLogLength)
-            });
-            tape = newTape;
+exports.run = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ descriptorName, args }, { loadConf, bundleCreate, bundleLoad, verifyLogFolder, ensureBuildsFolder, loadCurrentProfile, sendLogToAPI }) {
+        // Load forge configuration
+        const forge = await loadConf({});
+        const taskDescriptor = forge.tasks[descriptorName];
+        const projectName = forge.project.name;
+        if (taskDescriptor === undefined) {
+            throw new Error('Task is not defined on forge.json');
         }
-    }
-    catch (_error) {
-        // if the tape is not found, create a new one on saving
-    }
-    // Run the task with provided arguments
-    const [result, error, record] = await task.safeRun(args);
-    const logItem = tape.push(descriptorName, record, {
-        environment: 'cli'
-    });
-    await tape.save();
-    if (profile) {
+        // Try to load profile, but continue if not found
+        let profile = null;
         try {
-            await sendLogToAPI(profile, projectName, descriptorName, logItem);
+            profile = await loadCurrentProfile({});
         }
-        catch (e) {
-            console.error('Failed to send log to API:', e);
+        catch (error) {
+            // Profile not found or not configured, continue without it
+            console.log('No profile found, logs will not be sent to remote API');
         }
+        // Verify if log folder exists
+        const logFolderPath = path_1.default.join(process.cwd(), forge.paths.logs);
+        const logFolderExists = await verifyLogFolder(logFolderPath);
+        if (!logFolderExists) {
+            throw new Error(`Log folder "${logFolderPath}" does not exist`);
+        }
+        // Prepare paths
+        const logsPath = path_1.default.join(logFolderPath, descriptorName);
+        const entryPoint = path_1.default.join(process.cwd(), taskDescriptor.path);
+        const buildsPath = await ensureBuildsFolder();
+        const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
+        // Bundle the task
+        await bundleCreate({
+            entryPoint,
+            outputFile
+        });
+        // Load the bundled task
+        const bundle = await bundleLoad({
+            bundlePath: outputFile
+        });
+        // Get the task handler
+        const task = bundle[taskDescriptor.handler];
+        if (!task) {
+            throw new Error(`Handler "${taskDescriptor.handler}" not found in bundle`);
+        }
+        // Setup record tape
+        let tape = new record_tape_1.RecordTape({
+            path: logsPath
+        });
+        // load record tape
+        try {
+            await tape.load();
+            // Need to figure out how to handle the log length
+            // and other options for the RecordTape
+            // For now, we'll just keep the implementation simple
+            const maxLogLength = 9;
+            const log = tape.getLog();
+            if (log.length > maxLogLength) {
+                const newTape = new record_tape_1.RecordTape({
+                    path: logsPath,
+                    log: log.slice(-maxLogLength)
+                });
+                tape = newTape;
+            }
+        }
+        catch (_error) {
+            // if the tape is not found, create a new one on saving
+        }
+        // Run the task with provided arguments
+        const [result, error, record] = await task.safeRun(args);
+        const logItem = tape.push(descriptorName, record, {
+            environment: 'cli'
+        });
+        await tape.save();
+        if (profile) {
+            try {
+                await sendLogToAPI(profile, projectName, descriptorName, logItem);
+            }
+            catch (e) {
+                console.error('Failed to send log to API:', e);
+            }
+        }
+        if (error) {
+            throw error;
+        }
+        return result;
     }
-    if (error) {
-        throw error;
-    }
-    return result;
 });

package/dist/test/tasks/create.test.js

@@ -15,6 +15,7 @@ const expectedContent = `// TASK: newTask
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
 
+const name = 'sample:newTask'
 const description = 'Add task description here'
 
 const schema = new Schema({
@@ -27,10 +28,12 @@ const boundaries = {
   // example: readFile: async (path: string) => fs.readFile(path, 'utf-8')
 }
 
-export const newTask = createTask(
+export const newTask = createTask({
+  name,
+  description,
   schema,
   boundaries,
-  async function (argv, boundaries) {
+  fn: async function (argv, boundaries) {
     console.log('input:', argv)
     console.log('boundaries:', boundaries)
     // Your task implementation goes here
@@ -38,13 +41,11 @@ export const newTask = createTask(
 
     return status
   }
-)
+})
 
-newTask.setDescription(description)
 `;
 describe('Create task', () => {
     let volume;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let fs;
     let rootDir;
     beforeEach(() => {

package/dist/utils/taskAnalysis.d.ts

@@ -0,0 +1,21 @@
+interface SchemaProperty {
+    type: string;
+    optional?: boolean;
+    default?: string;
+}
+interface InputSchema {
+    type: string;
+    properties: Record<string, SchemaProperty>;
+}
+interface OutputType {
+    type: string;
+    properties?: Record<string, SchemaProperty>;
+}
+export interface TaskFingerprintOutput {
+    description?: string;
+    inputSchema: InputSchema;
+    outputType: OutputType;
+    boundaries: string[];
+}
+export declare function analyzeTaskFile(sourceCode: string, filePath: string, _expectedTaskName?: string): TaskFingerprintOutput | null;
+export {};