@forgehive/forge-cli 0.2.14 → 0.3.0

package/dist/tasks/task/describe.js

@@ -34,93 +34,97 @@ const boundaries = {
         return buildsPath;
     }
 };
-exports.describe = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName }, { loadConf, bundleCreate, bundleLoad, ensureBuildsFolder }) {
-    // Load forge configuration
-    const forge = await loadConf({});
-    const taskDescriptor = forge.tasks[descriptorName];
-    if (taskDescriptor === undefined) {
-        throw new Error(`Task "${descriptorName}" is not defined in forge.json`);
-    }
-    // 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`);
-    }
-    console.log('===============================================');
-    console.log(`Task: ${descriptorName}`);
-    console.log('===============================================');
-    console.log(`Path: ${taskDescriptor.path}`);
-    console.log(`Handler: ${taskDescriptor.handler}`);
-    // Get task description
-    const taskDescription = task.getDescription?.() || 'No description available';
-    console.log(`Description: ${taskDescription}`);
-    console.log('');
-    console.log('Schema:');
-    console.log('-------');
-    // Get schema information
-    const taskSchema = task.getSchema?.();
-    if (taskSchema && taskSchema.shape) {
-        const schemaKeys = Object.keys(taskSchema.shape);
-        if (schemaKeys.length === 0) {
-            console.log('  No schema parameters defined');
+exports.describe = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ descriptorName }, { loadConf, bundleCreate, bundleLoad, ensureBuildsFolder }) {
+        // Load forge configuration
+        const forge = await loadConf({});
+        const taskDescriptor = forge.tasks[descriptorName];
+        if (taskDescriptor === undefined) {
+            throw new Error(`Task "${descriptorName}" is not defined in forge.json`);
+        }
+        // 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`);
+        }
+        console.log('===============================================');
+        console.log(`Task: ${descriptorName}`);
+        console.log('===============================================');
+        console.log(`Path: ${taskDescriptor.path}`);
+        console.log(`Handler: ${taskDescriptor.handler}`);
+        // Get task description
+        const taskDescription = task.getDescription?.() || 'No description available';
+        console.log(`Description: ${taskDescription}`);
+        console.log('');
+        console.log('Schema:');
+        console.log('-------');
+        // Get schema information
+        const taskSchema = task.getSchema?.();
+        if (taskSchema && taskSchema.shape) {
+            const schemaKeys = Object.keys(taskSchema.shape);
+            if (schemaKeys.length === 0) {
+                console.log('  No schema parameters defined');
+            }
+            else {
+                schemaKeys.forEach(key => {
+                    const field = taskSchema.shape[key];
+                    const fieldType = field.type || 'unknown';
+                    const fieldDescription = field.description || '';
+                    if (fieldDescription) {
+                        console.log(`  • ${key} (${fieldType}): ${fieldDescription}`);
+                    }
+                    else {
+                        console.log(`  • ${key} (${fieldType})`);
+                    }
+                });
+            }
         }
         else {
-            schemaKeys.forEach(key => {
-                const field = taskSchema.shape[key];
-                const fieldType = field.type || 'unknown';
-                const fieldDescription = field.description || '';
-                if (fieldDescription) {
-                    console.log(`  • ${key} (${fieldType}): ${fieldDescription}`);
-                }
-                else {
-                    console.log(`  • ${key} (${fieldType})`);
-                }
-            });
+            console.log('  No schema information available');
         }
-    }
-    else {
-        console.log('  No schema information available');
-    }
-    console.log('');
-    console.log('Boundaries:');
-    console.log('-----------');
-    // Get boundaries information
-    const taskBoundaries = task.getBoundaries?.();
-    if (taskBoundaries) {
-        const boundaryKeys = Object.keys(taskBoundaries);
-        if (boundaryKeys.length === 0) {
-            console.log('  No boundaries defined');
+        console.log('');
+        console.log('Boundaries:');
+        console.log('-----------');
+        // Get boundaries information
+        const taskBoundaries = task.getBoundaries?.();
+        if (taskBoundaries) {
+            const boundaryKeys = Object.keys(taskBoundaries);
+            if (boundaryKeys.length === 0) {
+                console.log('  No boundaries defined');
+            }
+            else {
+                boundaryKeys.forEach(boundaryName => {
+                    console.log(`  • ${boundaryName}`);
+                });
+            }
         }
         else {
-            boundaryKeys.forEach(boundaryName => {
-                console.log(`  • ${boundaryName}`);
-            });
+            console.log('  No boundary information available');
         }
+        console.log('===============================================');
+        return {
+            name: descriptorName,
+            path: taskDescriptor.path,
+            handler: taskDescriptor.handler,
+            description: taskDescription,
+            schema: taskSchema?.shape || {},
+            boundaries: taskBoundaries ? Object.keys(taskBoundaries) : []
+        };
     }
-    else {
-        console.log('  No boundary information available');
-    }
-    console.log('===============================================');
-    return {
-        name: descriptorName,
-        path: taskDescriptor.path,
-        handler: taskDescriptor.handler,
-        description: taskDescription,
-        schema: taskSchema?.shape || {},
-        boundaries: taskBoundaries ? Object.keys(taskBoundaries) : []
-    };
 });
 exports.describe.setDescription(description);

package/dist/tasks/task/download.js

@@ -78,50 +78,53 @@ const boundaries = {
         }
     }
 };
-exports.download = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName, uuid }, { downloadTask, getCwd, parseTaskName, persistTask, loadConf, persistConf, checkTaskExists, loadCurrentProfile }) {
-    console.log(`Attempting to download task with descriptor: ${descriptorName} and uuid: ${uuid}`);
-    // Parse descriptor name to get task details
-    const { taskName, fileName, descriptor, dir } = await parseTaskName(descriptorName);
-    const profile = await loadCurrentProfile({});
-    const cwd = await getCwd();
-    const forge = await loadConf({});
-    let taskPath = forge.paths.tasks;
-    if (dir !== undefined) {
-        taskPath = path_1.default.join(taskPath, dir);
-    }
-    // Check if task already exists
-    const taskExists = await checkTaskExists(taskPath, fileName);
-    if (taskExists) {
-        console.log(`Task ${descriptor} already exists at ${taskPath}/${fileName}`);
-        return {
-            error: 'Task already exists',
-            taskPath: `${taskPath}/${fileName}`,
-            descriptor
-        };
-    }
-    // Download from hive api server
-    let response;
-    try {
-        response = await downloadTask(uuid, profile);
-    }
-    catch (e) {
-        const error = e;
-        console.error('Error downloading task:', error.message, error.status);
-        if (error.status === 404) {
+exports.download = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ descriptorName, uuid }, { downloadTask, getCwd, parseTaskName, persistTask, loadConf, persistConf, checkTaskExists, loadCurrentProfile }) {
+        console.log(`Attempting to download task with descriptor: ${descriptorName} and uuid: ${uuid}`);
+        // Parse descriptor name to get task details
+        const { taskName, fileName, descriptor, dir } = await parseTaskName(descriptorName);
+        const profile = await loadCurrentProfile({});
+        const cwd = await getCwd();
+        const forge = await loadConf({});
+        let taskPath = forge.paths.tasks;
+        if (dir !== undefined) {
+            taskPath = path_1.default.join(taskPath, dir);
+        }
+        // Check if task already exists
+        const taskExists = await checkTaskExists(taskPath, fileName);
+        if (taskExists) {
+            console.log(`Task ${descriptor} already exists at ${taskPath}/${fileName}`);
             return {
-                error: 'Task not found',
+                error: 'Task already exists',
                 taskPath: `${taskPath}/${fileName}`,
                 descriptor
             };
         }
-        return {
-            error: 'Failed to download task',
-            message: error.message,
-            taskPath: `${taskPath}/${fileName}`,
-            descriptor
-        };
-    }
-    console.log(`
+        // Download from hive api server
+        let response;
+        try {
+            response = await downloadTask(uuid, profile);
+        }
+        catch (e) {
+            const error = e;
+            console.error('Error downloading task:', error.message, error.status);
+            if (error.status === 404) {
+                return {
+                    error: 'Task not found',
+                    taskPath: `${taskPath}/${fileName}`,
+                    descriptor
+                };
+            }
+            return {
+                error: 'Failed to download task',
+                message: error.message,
+                taskPath: `${taskPath}/${fileName}`,
+                descriptor
+            };
+        }
+        console.log(`
     ==================================================
     Starting task download!
     Creating: ${taskName}
@@ -129,25 +132,26 @@ exports.download = (0, task_1.createTask)(schema, boundaries, async function ({
     Into: ${taskPath}
     ==================================================
     `);
-    console.log('Writing task file:', taskPath, fileName);
-    console.log('Handler:', response.handler);
-    console.log('Source code:', response.sourceCode);
-    // Persist task with cwd
-    await persistTask(taskPath, fileName, response.sourceCode, cwd);
-    // Update forge.json with the new task
-    if (forge.tasks === undefined) {
-        forge.tasks = {};
+        console.log('Writing task file:', taskPath, fileName);
+        console.log('Handler:', response.handler);
+        console.log('Source code:', response.sourceCode);
+        // Persist task with cwd
+        await persistTask(taskPath, fileName, response.sourceCode, cwd);
+        // Update forge.json with the new task
+        if (forge.tasks === undefined) {
+            forge.tasks = {};
+        }
+        forge.tasks[descriptor] = {
+            path: `${taskPath}/${fileName}`,
+            handler: response.handler
+        };
+        console.log('Forge:', forge);
+        await persistConf(forge, cwd);
+        return {
+            taskPath,
+            fileName,
+            descriptor,
+            handler: response.handler
+        };
     }
-    forge.tasks[descriptor] = {
-        path: `${taskPath}/${fileName}`,
-        handler: response.handler
-    };
-    console.log('Forge:', forge);
-    await persistConf(forge, cwd);
-    return {
-        taskPath,
-        fileName,
-        descriptor,
-        handler: response.handler
-    };
 });

package/dist/tasks/task/fingerprint.d.ts

@@ -0,0 +1,26 @@
+import { TaskFingerprintOutput } from '../../utils/taskAnalysis';
+export declare const fingerprint: import("@forgehive/task").TaskInstanceType<(argv: {
+    descriptorName: string;
+}, boundaries: import("@forgehive/task").WrappedBoundaries<{
+    getCwd: () => Promise<string>;
+    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    readFile: (filePath: string) => Promise<string>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+    ensureForgeFolder: () => Promise<string>;
+}>) => Promise<{
+    taskName: string;
+    fingerprint: TaskFingerprintOutput;
+    fingerprintFile: string;
+    analysis: {
+        inputSchemaProps: string[];
+        boundaryCount: number;
+        hasDescription: boolean;
+        outputType: string;
+    };
+}>, {
+    getCwd: () => Promise<string>;
+    loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
+    readFile: (filePath: string) => Promise<string>;
+    writeFile: (filePath: string, content: string) => Promise<void>;
+    ensureForgeFolder: () => Promise<string>;
+}>;

package/dist/tasks/task/fingerprint.js

@@ -0,0 +1,87 @@
+"use strict";
+// TASK: fingerprint
+// Run this task with:
+// forge task:run task:fingerprint --descriptorName task-name
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprint = void 0;
+const task_1 = require("@forgehive/task");
+const schema_1 = require("@forgehive/schema");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const load_1 = require("../conf/load");
+const taskAnalysis_1 = require("../../utils/taskAnalysis");
+const description = 'Analyze a specific task and generate detailed fingerprint without bundling';
+const schema = new schema_1.Schema({
+    descriptorName: schema_1.Schema.string()
+});
+const boundaries = {
+    getCwd: async () => {
+        return process.cwd();
+    },
+    loadConf: load_1.load.asBoundary(),
+    readFile: async (filePath) => {
+        return promises_1.default.readFile(filePath, 'utf-8');
+    },
+    writeFile: async (filePath, content) => {
+        return promises_1.default.writeFile(filePath, content);
+    },
+    ensureForgeFolder: async () => {
+        const forgePath = path_1.default.join(os_1.default.homedir(), '.forge');
+        try {
+            await promises_1.default.access(forgePath);
+        }
+        catch {
+            await promises_1.default.mkdir(forgePath, { recursive: true });
+        }
+        return forgePath;
+    }
+};
+exports.fingerprint = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ descriptorName }, { getCwd, loadConf, readFile, writeFile, ensureForgeFolder }) {
+        const cwd = await getCwd();
+        const forgeJson = await loadConf({});
+        const taskDescriptor = forgeJson.tasks[descriptorName];
+        if (taskDescriptor === undefined) {
+            throw new Error(`Task "${descriptorName}" is not defined in forge.json`);
+        }
+        const filePath = path_1.default.join(cwd, taskDescriptor.path);
+        const forgePath = await ensureForgeFolder();
+        const fingerprintFile = path_1.default.join(forgePath, `${descriptorName}.task-fingerprint.json`);
+        console.log(`Analyzing task: ${descriptorName}`);
+        console.log(`Task file: ${filePath}`);
+        // Read and analyze the task file using the utility function
+        const sourceCode = await readFile(filePath);
+        const taskFingerprint = (0, taskAnalysis_1.analyzeTaskFile)(sourceCode, filePath);
+        if (!taskFingerprint) {
+            throw new Error('Could not extract fingerprint from task file: ' + filePath);
+        }
+        // Create analysis result - clean output without extra fields
+        const analysis = {
+            taskFingerprint
+        };
+        // Write fingerprint to file
+        await writeFile(fingerprintFile, JSON.stringify(analysis, null, 2));
+        console.log('Task fingerprint generated successfully');
+        console.log(`Input properties: ${Object.keys(taskFingerprint.inputSchema.properties).join(', ')}`);
+        console.log(`Boundaries: ${taskFingerprint.boundaries.join(', ')}`);
+        console.log(`Fingerprint saved to: ${fingerprintFile}`);
+        return {
+            taskName: descriptorName,
+            fingerprint: taskFingerprint,
+            fingerprintFile,
+            analysis: {
+                inputSchemaProps: Object.keys(taskFingerprint.inputSchema.properties),
+                boundaryCount: taskFingerprint.boundaries.length,
+                hasDescription: !!taskFingerprint.description,
+                outputType: taskFingerprint.outputType.type
+            }
+        };
+    }
+});
+exports.fingerprint.setDescription(description);

package/dist/tasks/task/list.js

@@ -14,29 +14,33 @@ const schema = new schema_1.Schema({
 const boundaries = {
     loadConf: load_1.load.asBoundary()
 };
-exports.list = (0, task_1.createTask)(schema, boundaries, async function (argv, { loadConf }) {
-    // Load forge configuration
-    const forge = await loadConf({});
-    console.log('Available tasks:');
-    console.log('===============================================');
-    const tasks = forge.tasks;
-    const taskNames = Object.keys(tasks).sort();
-    if (taskNames.length === 0) {
-        console.log('No tasks found in forge.json');
-        return { taskCount: 0, tasks: [] };
+exports.list = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function (argv, { loadConf }) {
+        // Load forge configuration
+        const forge = await loadConf({});
+        console.log('Available tasks:');
+        console.log('===============================================');
+        const tasks = forge.tasks;
+        const taskNames = Object.keys(tasks).sort();
+        if (taskNames.length === 0) {
+            console.log('No tasks found in forge.json');
+            return { taskCount: 0, tasks: [] };
+        }
+        // Find the longest task name for alignment
+        const maxNameLength = Math.max(...taskNames.map(name => name.length));
+        taskNames.forEach((taskName) => {
+            const task = tasks[taskName];
+            const paddedName = taskName.padEnd(maxNameLength + 1);
+            console.log(`• ${paddedName} - ${task.path}`);
+        });
+        console.log('===============================================');
+        console.log('Total tasks: ', taskNames.length);
+        console.log('===============================================');
+        return {
+            taskCount: taskNames.length
+        };
     }
-    // Find the longest task name for alignment
-    const maxNameLength = Math.max(...taskNames.map(name => name.length));
-    taskNames.forEach((taskName) => {
-        const task = tasks[taskName];
-        const paddedName = taskName.padEnd(maxNameLength + 1);
-        console.log(`• ${paddedName} - ${task.path}`);
-    });
-    console.log('===============================================');
-    console.log('Total tasks: ', taskNames.length);
-    console.log('===============================================');
-    return {
-        taskCount: taskNames.length
-    };
 });
 exports.list.setDescription(description);

package/dist/tasks/task/publish.js

@@ -77,74 +77,78 @@ const boundaries = {
         return buildsPath;
     }
 };
-exports.publish = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName }, { getCwd, ensureBuildsFolder, loadConf, bundleCreate, bundleLoad, bundleZip, readFileUtf8, readFileBinary, publishTask, loadCurrentProfile, uploadBundleWithPresignedUrl }) {
-    const cwd = await getCwd();
-    const forgeJson = await loadConf({});
-    const profile = await loadCurrentProfile({});
-    const taskDescriptor = forgeJson.tasks[descriptorName];
-    const projectName = forgeJson.project.name;
-    if (taskDescriptor === undefined) {
-        throw new Error('Task is not defined on forge.json');
-    }
-    const entryPoint = path_1.default.join(cwd, taskDescriptor.path);
-    const buildsPath = await ensureBuildsFolder();
-    const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
-    const zipFile = `${descriptorName}.zip`;
-    // Bundle the task
-    await bundleCreate({
-        entryPoint,
-        outputFile
-    });
-    console.log('Bundle created...');
-    // Zip the bundle
-    await bundleZip({
-        dir: buildsPath,
-        input: `${descriptorName}.js`,
-        output: zipFile
-    });
-    console.log('Bundle zipped...');
-    // Load the bundled task
-    const bundle = await bundleLoad({
-        bundlePath: outputFile
-    });
-    // Get the task handler
-    const task = bundle[taskDescriptor.handler];
-    const description = task.getDescription() ?? '';
-    const schema = task.getSchema() || new schema_1.Schema({});
-    const boundaries = Object.keys(task.getBoundaries()) || [];
-    const schemaDescriptor = schema.describe();
-    // Read the task file content
-    const sourceCode = await readFileUtf8(entryPoint);
-    // Read the zipped bundle instead of the raw bundle
-    const zipPath = path_1.default.join(buildsPath, zipFile);
-    const bundleContent = await readFileBinary(zipPath);
-    // Get bundle size
-    const bundleSize = bundleContent.length;
-    // First, publish task metadata and get presigned URL for bundle upload
-    const data = {
-        ...taskDescriptor,
-        taskName: descriptorName,
-        handler: taskDescriptor.handler,
-        projectName,
-        description,
-        schemaDescriptor: JSON.stringify(schemaDescriptor),
-        boundaries,
-        sourceCode,
-        bundleSize
-    };
-    // Publish metadata to hive api server
-    console.log(`Publishing metadata and source code to ${profile.url}...`);
-    const publishResponse = await publishTask(data, profile);
-    // Upload zipped bundle using the presigned URL
-    if (publishResponse.bundleUploadUrl) {
-        console.log('Uploading zipped bundle...');
-        await uploadBundleWithPresignedUrl(publishResponse.bundleUploadUrl, bundleContent);
-        return {
-            descriptor: taskDescriptor,
-            publish: true
+exports.publish = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ descriptorName }, { getCwd, ensureBuildsFolder, loadConf, bundleCreate, bundleLoad, bundleZip, readFileUtf8, readFileBinary, publishTask, loadCurrentProfile, uploadBundleWithPresignedUrl }) {
+        const cwd = await getCwd();
+        const forgeJson = await loadConf({});
+        const profile = await loadCurrentProfile({});
+        const taskDescriptor = forgeJson.tasks[descriptorName];
+        const projectName = forgeJson.project.name;
+        if (taskDescriptor === undefined) {
+            throw new Error('Task is not defined on forge.json');
+        }
+        const entryPoint = path_1.default.join(cwd, taskDescriptor.path);
+        const buildsPath = await ensureBuildsFolder();
+        const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
+        const zipFile = `${descriptorName}.zip`;
+        // Bundle the task
+        await bundleCreate({
+            entryPoint,
+            outputFile
+        });
+        console.log('Bundle created...');
+        // Zip the bundle
+        await bundleZip({
+            dir: buildsPath,
+            input: `${descriptorName}.js`,
+            output: zipFile
+        });
+        console.log('Bundle zipped...');
+        // Load the bundled task
+        const bundle = await bundleLoad({
+            bundlePath: outputFile
+        });
+        // Get the task handler
+        const task = bundle[taskDescriptor.handler];
+        const description = task.getDescription() ?? '';
+        const schema = task.getSchema() || new schema_1.Schema({});
+        const boundaries = Object.keys(task.getBoundaries()) || [];
+        const schemaDescriptor = schema.describe();
+        // Read the task file content
+        const sourceCode = await readFileUtf8(entryPoint);
+        // Read the zipped bundle instead of the raw bundle
+        const zipPath = path_1.default.join(buildsPath, zipFile);
+        const bundleContent = await readFileBinary(zipPath);
+        // Get bundle size
+        const bundleSize = bundleContent.length;
+        // First, publish task metadata and get presigned URL for bundle upload
+        const data = {
+            ...taskDescriptor,
+            taskName: descriptorName,
+            handler: taskDescriptor.handler,
+            projectName,
+            description,
+            schemaDescriptor: JSON.stringify(schemaDescriptor),
+            boundaries,
+            sourceCode,
+            bundleSize
         };
-    }
-    else {
-        throw new Error('Bundle upload failed');
+        // Publish metadata to hive api server
+        console.log(`Publishing metadata and source code to ${profile.url}...`);
+        const publishResponse = await publishTask(data, profile);
+        // Upload zipped bundle using the presigned URL
+        if (publishResponse.bundleUploadUrl) {
+            console.log('Uploading zipped bundle...');
+            await uploadBundleWithPresignedUrl(publishResponse.bundleUploadUrl, bundleContent);
+            return {
+                descriptor: taskDescriptor,
+                publish: true
+            };
+        }
+        else {
+            throw new Error('Bundle upload failed');
+        }
     }
 });