@forgehive/forge-cli 0.3.6 → 0.3.8

package/dist/runner.js

@@ -115,9 +115,13 @@ runner.setHandler(async (data) => {
             });
         }
         else if (taskName === 'task:run') {
+            const { input, ...restArgs } = args;
+            // If --input is provided, parse it as JSON and use that
+            // Otherwise, use the regular arguments spread from minimist
+            const taskArgs = input ? JSON.parse(input) : restArgs;
             result = await task.run({
                 descriptorName: action,
-                args
+                args: taskArgs
             });
         }
         else if (taskName === 'fixture:download') {
@@ -144,6 +148,9 @@ runner.setHandler(async (data) => {
         }
         else {
             result = await task.run(args);
+            if (taskName === 'info') {
+                silent = true;
+            }
         }
         if (taskName === 'task:describe' || taskName === 'task:list') {
             silent = true;

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

@@ -7,9 +7,14 @@ export declare const fingerprint: import("@forgehive/task").TaskInstanceType<(ar
     loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
     readFile: (filePath: string) => Promise<string>;
     writeFile: (filePath: string, content: string) => Promise<void>;
-    ensureForgeFolder: () => Promise<string>;
+    ensureFingerprintsFolder: (cwd: string, conf: {
+        paths?: {
+            fingerprints?: string;
+        };
+    }) => Promise<string>;
 }>) => Promise<{
     taskFingerprint: TaskFingerprintOutput;
+    fingerprintFile: string;
     outputFile?: undefined;
     fingerprintsFile?: undefined;
     taskFingerprints?: undefined;
@@ -27,10 +32,15 @@ export declare const fingerprint: import("@forgehive/task").TaskInstanceType<(ar
         }[];
     };
     taskFingerprint?: undefined;
+    fingerprintFile?: 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>;
+    ensureFingerprintsFolder: (cwd: string, conf: {
+        paths?: {
+            fingerprints?: string;
+        };
+    }) => Promise<string>;
 }>;

package/dist/tasks/bundle/fingerprint.js

@@ -12,7 +12,6 @@ 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';
@@ -31,15 +30,15 @@ const boundaries = {
     writeFile: async (filePath, content) => {
         return promises_1.default.writeFile(filePath, content);
     },
-    ensureForgeFolder: async () => {
-        const forgePath = path_1.default.join(os_1.default.homedir(), '.forge');
+    ensureFingerprintsFolder: async (cwd, conf) => {
+        const fingerprintsPath = path_1.default.join(cwd, conf.paths?.fingerprints || 'fingerprints/');
         try {
-            await promises_1.default.access(forgePath);
+            await promises_1.default.access(fingerprintsPath);
         }
         catch {
-            await promises_1.default.mkdir(forgePath, { recursive: true });
+            await promises_1.default.mkdir(fingerprintsPath, { recursive: true });
         }
-        return forgePath;
+        return fingerprintsPath;
     }
 };
 // esbuild plugin for fingerprinting
@@ -66,6 +65,8 @@ function taskFingerprintPlugin() {
                             inputSchema: taskFingerprint.inputSchema,
                             outputType: taskFingerprint.outputType,
                             boundaries: taskFingerprint.boundaries,
+                            errors: taskFingerprint.errors,
+                            analysisMetadata: taskFingerprint.analysisMetadata,
                             hash: 'generated-hash'
                         };
                         fingerprints.push(fullFingerprint);
@@ -83,7 +84,7 @@ function taskFingerprintPlugin() {
 exports.fingerprint = (0, task_1.createTask)({
     schema,
     boundaries,
-    fn: async function ({ descriptorName, filePath }, { getCwd, loadConf, readFile, writeFile, ensureForgeFolder }) {
+    fn: async function ({ descriptorName, filePath }, { getCwd, loadConf, readFile, writeFile, ensureFingerprintsFolder }) {
         // If filePath is provided, analyze that file directly and return JSON
         if (filePath) {
             console.log(`Analyzing task file: ${filePath}`);
@@ -92,9 +93,20 @@ exports.fingerprint = (0, task_1.createTask)({
             if (!fingerprintOutput) {
                 throw new Error('Could not extract fingerprint from task file: ' + filePath);
             }
-            return {
+            // Write fingerprint to file for consistency
+            const cwd = await getCwd();
+            const forgeJson = await loadConf({});
+            const fingerprintsPath = await ensureFingerprintsFolder(cwd, forgeJson);
+            const fingerprintFile = path_1.default.join(fingerprintsPath, `${descriptorName}.fingerprint.json`);
+            const analysis = {
                 taskFingerprint: fingerprintOutput
             };
+            await writeFile(fingerprintFile, JSON.stringify(analysis, null, 2));
+            console.log(`Fingerprint saved to: ${fingerprintFile}`);
+            return {
+                taskFingerprint: fingerprintOutput,
+                fingerprintFile
+            };
         }
         // Original bundle logic when no filePath is provided
         const cwd = await getCwd();
@@ -104,9 +116,9 @@ exports.fingerprint = (0, task_1.createTask)({
             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`);
+        const fingerprintsPath = await ensureFingerprintsFolder(cwd, forgeJson);
+        const outputFile = path_1.default.join(fingerprintsPath, `${descriptorName}.js`);
+        const fingerprintsFile = path_1.default.join(fingerprintsPath, `${descriptorName}.fingerprints.json`);
         console.log(`Generating bundle with fingerprints for task: ${descriptorName}`);
         console.log(`Entry point: ${entryPoint}`);
         console.log(`Output: ${outputFile}`);
@@ -128,7 +140,9 @@ exports.fingerprint = (0, task_1.createTask)({
             description: fp.description,
             inputSchema: fp.inputSchema,
             outputType: fp.outputType,
-            boundaries: fp.boundaries
+            boundaries: fp.boundaries,
+            errors: fp.errors, // Preserve errors from analyzeTaskFile
+            analysisMetadata: fp.analysisMetadata // Preserve metadata from analyzeTaskFile
         }));
         // Create fingerprint result
         const fingerprintResult = {

package/dist/tasks/conf/info.d.ts

@@ -1,10 +1,21 @@
 export declare const info: import("@forgehive/task").TaskInstanceType<(argv: {}, boundaries: import("@forgehive/task").WrappedBoundaries<{
     readFile: (filePath: string) => Promise<string>;
+    loadConfig: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
     loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
 }>) => Promise<{
     version: any;
-    profile: {};
+    profile: {
+        name: string;
+        url: string;
+        apiKey: string;
+    } | null;
+    paths: {
+        logs: string;
+        fixtures: string;
+        fingerprints: string;
+    };
 }>, {
     readFile: (filePath: string) => Promise<string>;
+    loadConfig: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
     loadCurrentProfile: (args: {}) => Promise<Promise<import("../types").Profile>>;
 }>;

package/dist/tasks/conf/info.js

@@ -42,34 +42,58 @@ const schema_1 = require("@forgehive/schema");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const loadCurrent_1 = require("../auth/loadCurrent");
+const load_1 = require("../conf/load");
 const schema = new schema_1.Schema({});
 const boundaries = {
     readFile: async (filePath) => fs.promises.readFile(filePath, 'utf-8'),
+    loadConfig: load_1.load.asBoundary(),
     loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary()
 };
 exports.info = (0, task_1.createTask)({
     schema,
     boundaries,
-    fn: async function (_argv, { loadCurrentProfile, readFile }) {
+    fn: async function (_argv, { loadCurrentProfile, loadConfig, readFile }) {
         const packageJsonPath = path.join(__dirname, '../../../package.json');
         const packageJsonContent = await readFile(packageJsonPath);
         const packageJson = JSON.parse(packageJsonContent);
-        const info = {
-            version: packageJson.version,
-            profile: {}
-        };
+        const config = await loadConfig({});
+        // Display human-friendly information
+        console.log('===============================================');
+        console.log('============ Forge CLI Information ============');
+        console.log();
+        console.log(`Version: ${packageJson.version}`);
+        console.log();
+        console.log('Configuration Paths:');
+        console.log(`  Logs: ${config.paths.logs}`);
+        console.log(`  Fixtures: ${config.paths.fixtures}`);
+        console.log(`  Fingerprints: ${config.paths.fingerprints}`);
+        console.log();
         let profile;
         try {
             profile = await loadCurrentProfile({});
-            info.profile = {
-                name: profile.name,
-                url: profile.url,
-                apiKey: profile.apiKey
-            };
+            console.log('Current Profile:');
+            console.log(`  Name: ${profile.name}`);
+            console.log(`  URL: ${profile.url}`);
+            console.log(`  API Key: ${profile.apiKey}`);
         }
         catch (error) {
-            console.log('No default profile set. Please run forge task:run auth:add to create a profile.');
+            console.log('Current Profile: No default profile set');
+            console.log('  Run "forge task:run auth:add" to create a profile.');
         }
-        return info;
+        console.log();
+        console.log('===============================================');
+        return {
+            version: packageJson.version,
+            profile: profile ? {
+                name: profile.name,
+                url: profile.url,
+                apiKey: profile.apiKey
+            } : null,
+            paths: {
+                logs: config.paths.logs,
+                fixtures: config.paths.fixtures,
+                fingerprints: config.paths.fingerprints
+            }
+        };
     }
 });

package/dist/tasks/init.js

@@ -35,6 +35,7 @@ exports.init = (0, task_1.createTask)({
             paths: {
                 logs: 'logs/',
                 fixtures: 'fixtures/',
+                fingerprints: 'fingerprints/',
                 tasks: 'src/tasks/',
                 runners: 'src/runners/',
                 tests: 'src/tests/'

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

@@ -1,15 +1,36 @@
-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>;
+    bundleFingerprint: (args: {
+        descriptorName: string;
+        filePath?: string | undefined;
+    }) => Promise<Promise<{
+        taskFingerprint: import("../../utils/taskAnalysis").TaskFingerprintOutput;
+        fingerprintFile: string;
+        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;
+        fingerprintFile?: undefined;
+    }>>;
 }>) => Promise<{
     taskName: string;
-    fingerprint: TaskFingerprintOutput;
+    fingerprint: import("../../utils/taskAnalysis").TaskFingerprintOutput;
     fingerprintFile: string;
     analysis: {
         inputSchemaProps: string[];
@@ -20,7 +41,29 @@ export declare const fingerprint: import("@forgehive/task").TaskInstanceType<(ar
 }>, {
     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>;
+    bundleFingerprint: (args: {
+        descriptorName: string;
+        filePath?: string | undefined;
+    }) => Promise<Promise<{
+        taskFingerprint: import("../../utils/taskAnalysis").TaskFingerprintOutput;
+        fingerprintFile: string;
+        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;
+        fingerprintFile?: undefined;
+    }>>;
 }>;

package/dist/tasks/task/fingerprint.js

@@ -9,11 +9,9 @@ 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 fingerprint_1 = require("../bundle/fingerprint");
 const description = 'Analyze a specific task and generate detailed fingerprint without bundling';
 const schema = new schema_1.Schema({
     descriptorName: schema_1.Schema.string()
@@ -23,27 +21,12 @@ const boundaries = {
         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;
-    }
+    bundleFingerprint: fingerprint_1.fingerprint.asBoundary()
 };
 exports.fingerprint = (0, task_1.createTask)({
     schema,
     boundaries,
-    fn: async function ({ descriptorName }, { getCwd, loadConf, readFile, writeFile, ensureForgeFolder }) {
+    fn: async function ({ descriptorName }, { getCwd, loadConf, bundleFingerprint }) {
         const cwd = await getCwd();
         const forgeJson = await loadConf({});
         const taskDescriptor = forgeJson.tasks[descriptorName];
@@ -51,30 +34,24 @@ exports.fingerprint = (0, task_1.createTask)({
             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);
+        // Use bundle:fingerprint with filePath to analyze the task file directly
+        const result = await bundleFingerprint({
+            descriptorName,
+            filePath
+        });
+        const taskFingerprint = result.taskFingerprint;
         if (!taskFingerprint) {
-            throw new Error('Could not extract fingerprint from task file: ' + filePath);
+            throw new Error('Could not extract fingerprint from task file');
         }
-        // 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}`);
+        console.log(`Boundaries: ${taskFingerprint.boundaries.map(b => b.name).join(', ')}`);
         return {
             taskName: descriptorName,
             fingerprint: taskFingerprint,
-            fingerprintFile,
+            fingerprintFile: result.fingerprintFile,
             analysis: {
                 inputSchemaProps: Object.keys(taskFingerprint.inputSchema.properties),
                 boundaryCount: taskFingerprint.boundaries.length,

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

@@ -1,4 +1,5 @@
 import { Profile } from '../types';
+import { TaskFingerprintOutput } from '../../utils/taskAnalysis';
 export declare const publish: import("@forgehive/task").TaskInstanceType<(argv: {
     descriptorName: string;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
@@ -19,14 +20,42 @@ export declare const publish: import("@forgehive/task").TaskInstanceType<(argv:
         input: string;
         output: string;
     }) => Promise<Promise<unknown>>;
+    bundleFingerprint: (args: {
+        descriptorName: string;
+        filePath?: string | undefined;
+    }) => Promise<Promise<{
+        taskFingerprint: TaskFingerprintOutput;
+        fingerprintFile: string;
+        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;
+        fingerprintFile?: undefined;
+    }>>;
     readFileUtf8: (filePath: string) => Promise<string>;
     readFileBinary: (filePath: string) => Promise<Buffer>;
-    publishTask: (data: any, profile: Profile) => Promise<any>;
-    uploadBundleWithPresignedUrl: (presignedUrl: string, bundleContent: Buffer) => Promise<any>;
+    publishTask: (data: Record<string, unknown>, profile: Profile) => Promise<{
+        bundleUploadUrl?: string;
+    }>;
+    uploadBundleWithPresignedUrl: (presignedUrl: string, bundleContent: Buffer) => Promise<boolean>;
     ensureBuildsFolder: () => Promise<string>;
 }>) => Promise<{
     descriptor: import("../types").TaskDescriptor;
     publish: boolean;
+    fingerprint: boolean;
 }>, {
     getCwd: () => Promise<string>;
     loadConf: (args: {}) => Promise<Promise<import("../types").ForgeConf>>;
@@ -45,9 +74,36 @@ export declare const publish: import("@forgehive/task").TaskInstanceType<(argv:
         input: string;
         output: string;
     }) => Promise<Promise<unknown>>;
+    bundleFingerprint: (args: {
+        descriptorName: string;
+        filePath?: string | undefined;
+    }) => Promise<Promise<{
+        taskFingerprint: TaskFingerprintOutput;
+        fingerprintFile: string;
+        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;
+        fingerprintFile?: undefined;
+    }>>;
     readFileUtf8: (filePath: string) => Promise<string>;
     readFileBinary: (filePath: string) => Promise<Buffer>;
-    publishTask: (data: any, profile: Profile) => Promise<any>;
-    uploadBundleWithPresignedUrl: (presignedUrl: string, bundleContent: Buffer) => Promise<any>;
+    publishTask: (data: Record<string, unknown>, profile: Profile) => Promise<{
+        bundleUploadUrl?: string;
+    }>;
+    uploadBundleWithPresignedUrl: (presignedUrl: string, bundleContent: Buffer) => Promise<boolean>;
     ensureBuildsFolder: () => Promise<string>;
 }>;

package/dist/tasks/task/publish.js

@@ -17,6 +17,7 @@ const load_1 = require("../conf/load");
 const create_1 = require("../bundle/create");
 const load_2 = require("../bundle/load");
 const zip_1 = require("../bundle/zip");
+const fingerprint_1 = require("../bundle/fingerprint");
 const loadCurrent_1 = require("../auth/loadCurrent");
 const schema = new schema_1.Schema({
     descriptorName: schema_1.Schema.string()
@@ -30,13 +31,13 @@ const boundaries = {
     bundleCreate: create_1.create.asBoundary(),
     bundleLoad: load_2.load.asBoundary(),
     bundleZip: zip_1.zip.asBoundary(),
+    bundleFingerprint: fingerprint_1.fingerprint.asBoundary(),
     readFileUtf8: async (filePath) => {
         return promises_1.default.readFile(filePath, 'utf-8');
     },
     readFileBinary: async (filePath) => {
         return promises_1.default.readFile(filePath);
     },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     publishTask: async (data, profile) => {
         const publishUrl = `${profile.url}/api/tasks/publish`;
         const authToken = `${profile.apiKey}:${profile.apiSecret}`;
@@ -48,16 +49,17 @@ const boundaries = {
                 }
             });
             return response.data;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (error) {
-            if (error.response?.data?.error.includes('Bundle size')) {
-                throw new Error('Bundle size exceeds the maximum allowed size of 25MB');
+            if (error && typeof error === 'object' && 'response' in error) {
+                const axiosError = error;
+                if (axiosError.response?.data?.error?.includes('Bundle size')) {
+                    throw new Error('Bundle size exceeds the maximum allowed size of 25MB');
+                }
             }
             throw new Error('Failed to publish task source code and metadata');
         }
     },
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     uploadBundleWithPresignedUrl: async (presignedUrl, bundleContent) => {
         const response = await axios_1.default.put(presignedUrl, bundleContent, {
             headers: {
@@ -80,7 +82,7 @@ const boundaries = {
 exports.publish = (0, task_1.createTask)({
     schema,
     boundaries,
-    fn: async function ({ descriptorName }, { getCwd, ensureBuildsFolder, loadConf, bundleCreate, bundleLoad, bundleZip, readFileUtf8, readFileBinary, publishTask, loadCurrentProfile, uploadBundleWithPresignedUrl }) {
+    fn: async function ({ descriptorName }, { getCwd, ensureBuildsFolder, loadConf, bundleCreate, bundleLoad, bundleZip, bundleFingerprint, readFileUtf8, readFileBinary, publishTask, loadCurrentProfile, uploadBundleWithPresignedUrl }) {
         const cwd = await getCwd();
         const forgeJson = await loadConf({});
         const profile = await loadCurrentProfile({});
@@ -106,6 +108,24 @@ exports.publish = (0, task_1.createTask)({
             output: zipFile
         });
         console.log('Bundle zipped...');
+        // Generate task fingerprint
+        console.log('Generating task fingerprint...');
+        let taskFingerprintData = null;
+        try {
+            const fingerprintResult = await bundleFingerprint({
+                descriptorName,
+                filePath: entryPoint
+            });
+            // Bundle fingerprint returns the fingerprint data directly
+            if (fingerprintResult.taskFingerprint) {
+                taskFingerprintData = fingerprintResult.taskFingerprint;
+                console.log('Task fingerprint generated successfully');
+            }
+        }
+        catch (error) {
+            console.warn('Failed to generate task fingerprint:', error instanceof Error ? error.message : String(error));
+            console.warn('Publishing without fingerprint data...');
+        }
         // Load the bundled task
         const bundle = await bundleLoad({
             bundlePath: outputFile
@@ -133,7 +153,8 @@ exports.publish = (0, task_1.createTask)({
             schemaDescriptor: JSON.stringify(schemaDescriptor),
             boundaries,
             sourceCode,
-            bundleSize
+            bundleSize,
+            ...(taskFingerprintData && { fingerprint: taskFingerprintData })
         };
         // Publish metadata to hive api server
         console.log(`Publishing metadata and source code to ${profile.url}...`);
@@ -144,7 +165,8 @@ exports.publish = (0, task_1.createTask)({
             await uploadBundleWithPresignedUrl(publishResponse.bundleUploadUrl, bundleContent);
             return {
                 descriptor: taskDescriptor,
-                publish: true
+                publish: true,
+                fingerprint: taskFingerprintData !== null
             };
         }
         else {

package/dist/tasks/types.d.ts

@@ -24,6 +24,7 @@ export interface ForgeConf {
         tasks: string;
         runners: string;
         fixtures: string;
+        fingerprints: string;
         tests: string;
     };
     infra: Infra;

package/dist/utils/taskAnalysis.d.ts

@@ -1,7 +1,9 @@
 interface SchemaProperty {
+    name?: string;
     type: string;
     optional?: boolean;
     default?: string;
+    properties?: Record<string, SchemaProperty>;
 }
 interface InputSchema {
     type: string;
@@ -10,12 +12,36 @@ interface InputSchema {
 interface OutputType {
     type: string;
     properties?: Record<string, SchemaProperty>;
+    elementType?: OutputType;
+}
+export interface FingerprintError {
+    type: 'parsing' | 'analysis' | 'boundary' | 'schema';
+    message: string;
+    location?: {
+        file: string;
+        line?: number;
+        column?: number;
+    };
+    details?: Record<string, unknown>;
+}
+interface BoundaryFingerprint {
+    name: string;
+    input: SchemaProperty[];
+    output: OutputType;
+    errors: FingerprintError[];
 }
 export interface TaskFingerprintOutput {
     description?: string;
     inputSchema: InputSchema;
     outputType: OutputType;
-    boundaries: string[];
+    boundaries: BoundaryFingerprint[];
+    errors: FingerprintError[];
+    analysisMetadata: {
+        timestamp: string;
+        filePath: string;
+        success: boolean;
+        analysisVersion: string;
+    };
 }
 export declare function analyzeTaskFile(sourceCode: string, filePath: string, _expectedTaskName?: string): TaskFingerprintOutput | null;
 export {};