@forgehive/forge-cli 0.2.14 → 0.3.1

package/dist/runner.js

@@ -18,6 +18,7 @@ const download_1 = require("./tasks/task/download");
 const replay_1 = require("./tasks/task/replay");
 const list_1 = require("./tasks/task/list");
 const describe_1 = require("./tasks/task/describe");
+const fingerprint_1 = require("./tasks/task/fingerprint");
 const create_1 = require("./tasks/runner/create");
 const remove_2 = require("./tasks/runner/remove");
 const bundle_1 = require("./tasks/runner/bundle");
@@ -46,6 +47,7 @@ runner.load('task:download', download_1.download);
 runner.load('task:replay', replay_1.replay);
 runner.load('task:list', list_1.list);
 runner.load('task:describe', describe_1.describe);
+runner.load('task:fingerprint', fingerprint_1.fingerprint);
 // Runner commands
 runner.load('runner:create', create_1.create);
 runner.load('runner:remove', remove_2.remove);
@@ -71,7 +73,7 @@ runner.setHandler(async (data) => {
     }
     try {
         let result;
-        const commandsWithDescriptor = ['task:create', 'task:remove', 'task:publish', 'task:describe'];
+        const commandsWithDescriptor = ['task:create', 'task:remove', 'task:publish', 'task:describe', 'task:fingerprint'];
         const commandsWithRunner = ['runner:create', 'runner:remove'];
         if (commandsWithDescriptor.includes(taskName)) {
             result = await task.run({ descriptorName: action });

package/dist/tasks/auth/add.js

@@ -27,24 +27,28 @@ const boundaries = {
         await promises_1.default.writeFile(profilesPath, JSON.stringify(profiles, null, 2));
     }
 };
-exports.add = (0, task_1.createTask)(schema, boundaries, async function ({ name, apiKey, apiSecret, url }, { loadProfiles, persistProfiles }) {
-    const profiles = await loadProfiles({});
-    // Check if profile with same name already exists
-    const existingProfileIndex = profiles.profiles.findIndex(p => p.name === name);
-    if (existingProfileIndex >= 0) {
-        // Replace existing profile
-        profiles.profiles[existingProfileIndex] = { name, apiKey, apiSecret, url };
+exports.add = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ name, apiKey, apiSecret, url }, { loadProfiles, persistProfiles }) {
+        const profiles = await loadProfiles({});
+        // Check if profile with same name already exists
+        const existingProfileIndex = profiles.profiles.findIndex(p => p.name === name);
+        if (existingProfileIndex >= 0) {
+            // Replace existing profile
+            profiles.profiles[existingProfileIndex] = { name, apiKey, apiSecret, url };
+        }
+        else {
+            // Add new profile
+            profiles.profiles.push({ name, apiKey, apiSecret, url });
+        }
+        // Set as default profile
+        profiles.default = name;
+        // Persist profiles
+        await persistProfiles(profiles);
+        return {
+            status: 'Ok',
+            message: `Profile '${name}' added and set as default`
+        };
     }
-    else {
-        // Add new profile
-        profiles.profiles.push({ name, apiKey, apiSecret, url });
-    }
-    // Set as default profile
-    profiles.default = name;
-    // Persist profiles
-    await persistProfiles(profiles);
-    return {
-        status: 'Ok',
-        message: `Profile '${name}' added and set as default`
-    };
 });

package/dist/tasks/auth/list.js

@@ -11,21 +11,25 @@ const schema = new schema_1.Schema({});
 const boundaries = {
     loadProfiles: load_1.load.asBoundary()
 };
-exports.list = (0, task_1.createTask)(schema, boundaries, async function (_argv, { loadProfiles }) {
-    const profiles = await loadProfiles({});
-    if (profiles.profiles.length === 0) {
-        console.log('No profiles found. Use auth:add to create one.');
-        return { status: 'Ok', profiles: [] };
+exports.list = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function (_argv, { loadProfiles }) {
+        const profiles = await loadProfiles({});
+        if (profiles.profiles.length === 0) {
+            console.log('No profiles found. Use auth:add to create one.');
+            return { status: 'Ok', profiles: [] };
+        }
+        console.log('Available profiles:');
+        profiles.profiles.forEach(profile => {
+            const isDefault = profile.name === profiles.default;
+            const prefix = isDefault ? '* ' : '  ';
+            console.log(`${prefix}${profile.name} - API Key: ${profile.apiKey}`);
+        });
+        console.log('\nUse auth:add to create or update a profile');
+        console.log('\nUse auth:switch to switch to a profile');
+        return {
+            default: profiles.default
+        };
     }
-    console.log('Available profiles:');
-    profiles.profiles.forEach(profile => {
-        const isDefault = profile.name === profiles.default;
-        const prefix = isDefault ? '* ' : '  ';
-        console.log(`${prefix}${profile.name} - API Key: ${profile.apiKey}`);
-    });
-    console.log('\nUse auth:add to create or update a profile');
-    console.log('\nUse auth:switch to switch to a profile');
-    return {
-        default: profiles.default
-    };
 });

package/dist/tasks/auth/load.js

@@ -25,20 +25,24 @@ const boundaries = {
         return buildsPath;
     }
 };
-exports.load = (0, task_1.createTask)(schema, boundaries, async function (argv, { ensureBuildsFolder }) {
-    const buildsPath = await ensureBuildsFolder();
-    let profiles = {
-        default: '',
-        profiles: []
-    };
-    const profilesPath = path_1.default.join(buildsPath, 'profiles.json');
-    try {
-        const content = await promises_1.default.readFile(profilesPath, 'utf-8');
-        profiles = JSON.parse(content);
-    }
-    catch (_error) {
-        console.log('Creating profiles.json');
-        await promises_1.default.writeFile(profilesPath, '{"profiles": [], "default": ""}');
+exports.load = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function (argv, { ensureBuildsFolder }) {
+        const buildsPath = await ensureBuildsFolder();
+        let profiles = {
+            default: '',
+            profiles: []
+        };
+        const profilesPath = path_1.default.join(buildsPath, 'profiles.json');
+        try {
+            const content = await promises_1.default.readFile(profilesPath, 'utf-8');
+            profiles = JSON.parse(content);
+        }
+        catch (_error) {
+            console.log('Creating profiles.json');
+            await promises_1.default.writeFile(profilesPath, '{"profiles": [], "default": ""}');
+        }
+        return profiles;
     }
-    return profiles;
 });

package/dist/tasks/auth/loadCurrent.js

@@ -11,14 +11,18 @@ const schema = new schema_1.Schema({});
 const boundaries = {
     loadProfiles: load_1.load.asBoundary()
 };
-exports.loadCurrent = (0, task_1.createTask)(schema, boundaries, async function (_argv, { loadProfiles }) {
-    const profiles = await loadProfiles({});
-    if (!profiles.default || profiles.default === '') {
-        throw new Error('No default profile set. Please run forge task:run auth:add to create a profile.');
+exports.loadCurrent = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function (_argv, { loadProfiles }) {
+        const profiles = await loadProfiles({});
+        if (!profiles.default || profiles.default === '') {
+            throw new Error('No default profile set. Please run forge task:run auth:add to create a profile.');
+        }
+        const defaultProfile = profiles.profiles.find(profile => profile.name === profiles.default);
+        if (!defaultProfile) {
+            throw new Error(`Default profile "${profiles.default}" not found in profiles.`);
+        }
+        return { ...defaultProfile, name: profiles.default };
     }
-    const defaultProfile = profiles.profiles.find(profile => profile.name === profiles.default);
-    if (!defaultProfile) {
-        throw new Error(`Default profile "${profiles.default}" not found in profiles.`);
-    }
-    return { ...defaultProfile, name: profiles.default };
 });

package/dist/tasks/auth/remove.js

@@ -24,33 +24,37 @@ const boundaries = {
         await promises_1.default.writeFile(profilesPath, JSON.stringify(profiles, null, 2));
     }
 };
-exports.remove = (0, task_1.createTask)(schema, boundaries, async function ({ profileName }, { loadProfiles, persistProfiles }) {
-    const profiles = await loadProfiles({});
-    // Check if profile exists
-    const profileExists = profiles.profiles.some(profile => profile.name === profileName);
-    if (!profileExists) {
-        throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`);
-    }
-    // Remove the profile using filter
-    profiles.profiles = profiles.profiles.filter(profile => profile.name !== profileName);
-    // If the removed profile was the default, update the default
-    if (profiles.default === profileName) {
-        if (profiles.profiles.length > 0) {
-            // Set the first available profile as default
-            profiles.default = profiles.profiles[0].name;
-            console.log(`Default profile set to: ${profiles.default}`);
+exports.remove = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ profileName }, { loadProfiles, persistProfiles }) {
+        const profiles = await loadProfiles({});
+        // Check if profile exists
+        const profileExists = profiles.profiles.some(profile => profile.name === profileName);
+        if (!profileExists) {
+            throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`);
         }
-        else {
-            // No profiles left, set default to empty
-            profiles.default = '';
-            console.log('No profiles left. Default set to empty.');
+        // Remove the profile using filter
+        profiles.profiles = profiles.profiles.filter(profile => profile.name !== profileName);
+        // If the removed profile was the default, update the default
+        if (profiles.default === profileName) {
+            if (profiles.profiles.length > 0) {
+                // Set the first available profile as default
+                profiles.default = profiles.profiles[0].name;
+                console.log(`Default profile set to: ${profiles.default}`);
+            }
+            else {
+                // No profiles left, set default to empty
+                profiles.default = '';
+                console.log('No profiles left. Default set to empty.');
+            }
         }
+        // Persist updated profiles
+        await persistProfiles(profiles);
+        console.log(`Profile "${profileName}" has been removed.`);
+        return {
+            status: 'Ok',
+            message: `Profile "${profileName}" has been removed.`
+        };
     }
-    // Persist updated profiles
-    await persistProfiles(profiles);
-    console.log(`Profile "${profileName}" has been removed.`);
-    return {
-        status: 'Ok',
-        message: `Profile "${profileName}" has been removed.`
-    };
 });

package/dist/tasks/auth/switch.js

@@ -24,20 +24,24 @@ const boundaries = {
         await promises_1.default.writeFile(profilesPath, JSON.stringify(profiles, null, 2));
     }
 };
-exports.switchProfile = (0, task_1.createTask)(schema, boundaries, async function ({ profileName }, { loadProfiles, persistProfiles }) {
-    // Load profiles
-    const profiles = await loadProfiles({});
-    // Check if profile exists
-    const profileExists = profiles.profiles.some(profile => profile.name === profileName);
-    if (!profileExists) {
-        throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`);
+exports.switchProfile = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ profileName }, { loadProfiles, persistProfiles }) {
+        // Load profiles
+        const profiles = await loadProfiles({});
+        // Check if profile exists
+        const profileExists = profiles.profiles.some(profile => profile.name === profileName);
+        if (!profileExists) {
+            throw new Error(`Profile "${profileName}" not found. Use auth:list to see available profiles.`);
+        }
+        // Update default profile
+        profiles.default = profileName;
+        // Save updated profiles
+        await persistProfiles(profiles);
+        console.log(`Switched to profile: ${profileName}`);
+        return {
+            default: profileName
+        };
     }
-    // Update default profile
-    profiles.default = profileName;
-    // Save updated profiles
-    await persistProfiles(profiles);
-    console.log(`Switched to profile: ${profileName}`);
-    return {
-        default: profileName
-    };
 });

package/dist/tasks/bundle/create.js

@@ -1,7 +1,7 @@
 "use strict";
 // TASK: create
 // Run this task with:
-// shadow-cli bundle:create
+// forge task:run bundle:create
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -15,15 +15,19 @@ const schema = new schema_1.Schema({
     outputFile: schema_1.Schema.string()
 });
 const boundaries = {};
-exports.create = (0, task_1.createTask)(schema, boundaries, async function ({ entryPoint, outputFile }) {
-    // Build using esbuild
-    await esbuild_1.default.build({
-        entryPoints: [entryPoint],
-        outfile: outputFile,
-        bundle: true,
-        minify: true,
-        platform: 'node',
-        sourcemap: true
-    });
-    return { outputFile };
+exports.create = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ entryPoint, outputFile }) {
+        // Build using esbuild
+        await esbuild_1.default.build({
+            entryPoints: [entryPoint],
+            outfile: outputFile,
+            bundle: true,
+            minify: true,
+            platform: 'node',
+            sourcemap: true
+        });
+        return { outputFile };
+    }
 });

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

@@ -0,0 +1,36 @@
+import { TaskFingerprintOutput } from '../../utils/taskAnalysis';
+export declare const fingerprint: import("@forgehive/task").TaskInstanceType<(argv: {
+    descriptorName: string;
+    filePath?: string | undefined;
+}, 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<{
+    taskFingerprint: TaskFingerprintOutput;
+    outputFile?: undefined;
+    fingerprintsFile?: undefined;
+    taskFingerprints?: undefined;
+} | {
+    outputFile: string;
+    fingerprintsFile: string;
+    taskFingerprints: {
+        totalTasks: number;
+        tasks: {
+            name: string;
+            inputType: string;
+            outputType: string;
+            boundaryCount: number;
+            hash: string;
+        }[];
+    };
+    taskFingerprint?: undefined;
+}>, {
+    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/bundle/fingerprint.js

@@ -0,0 +1,164 @@
+"use strict";
+// TASK: fingerprint
+// Run this task with:
+// forge task:run bundle: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 esbuild_1 = __importDefault(require("esbuild"));
+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 = 'Generate task bundle with comprehensive fingerprinting and type extraction';
+const schema = new schema_1.Schema({
+    descriptorName: schema_1.Schema.string(),
+    filePath: schema_1.Schema.string().optional()
+});
+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;
+    }
+};
+// esbuild plugin for fingerprinting
+function taskFingerprintPlugin() {
+    return {
+        name: 'task-fingerprint',
+        setup(build) {
+            const fingerprints = [];
+            build.onLoad({ filter: /\.ts$/ }, async (args) => {
+                const sourceCode = await promises_1.default.readFile(args.path, 'utf-8');
+                // Only analyze files that contain createTask
+                if (sourceCode.includes('createTask')) {
+                    const taskFingerprint = (0, taskAnalysis_1.analyzeTaskFile)(sourceCode, args.path);
+                    if (taskFingerprint) {
+                        // Convert to full TaskFingerprint for plugin compatibility
+                        const fullFingerprint = {
+                            name: path_1.default.basename(args.path, '.ts'),
+                            description: taskFingerprint.description,
+                            location: {
+                                file: args.path,
+                                line: 1,
+                                column: 1
+                            },
+                            inputSchema: taskFingerprint.inputSchema,
+                            outputType: taskFingerprint.outputType,
+                            boundaries: taskFingerprint.boundaries,
+                            hash: 'generated-hash'
+                        };
+                        fingerprints.push(fullFingerprint);
+                    }
+                }
+                return null; // Let esbuild handle the file normally
+            });
+            build.onEnd((result) => {
+                // Store fingerprints for later use
+                result.fingerprints = fingerprints;
+            });
+        }
+    };
+}
+exports.fingerprint = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ descriptorName, filePath }, { getCwd, loadConf, readFile, writeFile, ensureForgeFolder }) {
+        // If filePath is provided, analyze that file directly and return JSON
+        if (filePath) {
+            console.log(`Analyzing task file: ${filePath}`);
+            const sourceCode = await readFile(filePath);
+            const fingerprintOutput = (0, taskAnalysis_1.analyzeTaskFile)(sourceCode, filePath);
+            if (!fingerprintOutput) {
+                throw new Error('Could not extract fingerprint from task file: ' + filePath);
+            }
+            return {
+                taskFingerprint: fingerprintOutput
+            };
+        }
+        // Original bundle logic when no filePath is provided
+        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 entryPoint = path_1.default.join(cwd, taskDescriptor.path);
+        const forgePath = await ensureForgeFolder();
+        const outputFile = path_1.default.join(forgePath, `${descriptorName}.js`);
+        const fingerprintsFile = path_1.default.join(forgePath, `${descriptorName}.fingerprints.json`);
+        console.log(`Generating bundle with fingerprints for task: ${descriptorName}`);
+        console.log(`Entry point: ${entryPoint}`);
+        console.log(`Output: ${outputFile}`);
+        // Build with fingerprinting plugin
+        const result = await esbuild_1.default.build({
+            entryPoints: [entryPoint],
+            outfile: outputFile,
+            bundle: true,
+            minify: true,
+            platform: 'node',
+            sourcemap: true,
+            plugins: [taskFingerprintPlugin()],
+            metafile: true
+        });
+        // Extract fingerprints from build result
+        const taskFingerprints = result.fingerprints || [];
+        // Convert to simplified output format (remove name, location, hash)
+        const simplifiedFingerprints = taskFingerprints.map((fp) => ({
+            description: fp.description,
+            inputSchema: fp.inputSchema,
+            outputType: fp.outputType,
+            boundaries: fp.boundaries
+        }));
+        // Create fingerprint result
+        const fingerprintResult = {
+            tasks: simplifiedFingerprints,
+            buildInfo: {
+                entryPoint,
+                outputFile,
+                fingerprintsFile,
+                totalTasks: simplifiedFingerprints.length,
+                buildTimestamp: new Date().toISOString()
+            }
+        };
+        // Write fingerprints to file
+        await writeFile(fingerprintsFile, JSON.stringify(fingerprintResult, null, 2));
+        console.log(`Generated ${taskFingerprints.length} task fingerprints`);
+        console.log(`Fingerprints saved to: ${fingerprintsFile}`);
+        return {
+            outputFile,
+            fingerprintsFile,
+            taskFingerprints: {
+                totalTasks: taskFingerprints.length,
+                tasks: taskFingerprints.map((fp) => ({
+                    name: fp.name,
+                    inputType: fp.inputSchema.type,
+                    outputType: fp.outputType.type,
+                    boundaryCount: fp.boundaries.length,
+                    hash: fp.hash
+                }))
+            }
+        };
+    }
+});
+exports.fingerprint.setDescription(description);

package/dist/tasks/bundle/load.js

@@ -1,7 +1,7 @@
 "use strict";
 // TASK: load
 // Run this task with:
-// shadow-cli bundle:load
+// forge task:run bundle:load
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -43,8 +43,12 @@ const schema = new schema_1.Schema({
     bundlePath: schema_1.Schema.string()
 });
 const boundaries = {};
-exports.load = (0, task_1.createTask)(schema, boundaries, async function ({ bundlePath }) {
-    // Dynamically import the bundle from the specified path
-    const bundle = await Promise.resolve(`${bundlePath}`).then(s => __importStar(require(s)));
-    return bundle;
+exports.load = (0, task_1.createTask)({
+    schema,
+    boundaries,
+    fn: async function ({ bundlePath }) {
+        // Dynamically import the bundle from the specified path
+        const bundle = await Promise.resolve(`${bundlePath}`).then(s => __importStar(require(s)));
+        return bundle;
+    }
 });