@forgehive/forge-cli 0.3.6 → 0.3.7

package/src/tasks/conf/info.ts

@@ -8,41 +8,67 @@ import * as fs from 'fs'
 import * as path from 'path'
 
 import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+import { load as loadConfig } from '../conf/load'
 
 const schema = new Schema({})
 
 const boundaries = {
   readFile: async (filePath: string): Promise<string> => fs.promises.readFile(filePath, 'utf-8'),
+  loadConfig: loadConfig.asBoundary(),
   loadCurrentProfile: loadCurrentProfile.asBoundary()
 }
 
 export const info = 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({})
+      console.log('Current Profile:')
+      console.log(`  Name: ${profile.name}`)
+      console.log(`  URL: ${profile.url}`)
+      console.log(`  API Key: ${profile.apiKey}`)
+    } catch (error) {
+      console.log('Current Profile: No default profile set')
+      console.log('  Run "forge task:run auth:add" to create a profile.')
+    }
+
+    console.log()
+    console.log('===============================================')
 
-      info.profile = {
+    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
       }
-    } catch (error) {
-      console.log('No default profile set. Please run forge task:run auth:add to create a profile.')
     }
-
-    return info
   }
 })

package/src/tasks/init.ts

@@ -37,6 +37,7 @@ export const init = createTask({
       paths: {
         logs: 'logs/',
         fixtures: 'fixtures/',
+        fingerprints: 'fingerprints/',
         tasks: 'src/tasks/',
         runners: 'src/runners/',
         tests: 'src/tests/'

package/src/tasks/task/fingerprint.ts

@@ -4,16 +4,10 @@
 
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
-import fs from 'fs/promises'
 import path from 'path'
-import os from 'os'
 
 import { load as loadConf } from '../conf/load'
-import { analyzeTaskFile, TaskFingerprintOutput } from '../../utils/taskAnalysis'
-
-interface FingerprintAnalysis {
-  taskFingerprint: TaskFingerprintOutput
-}
+import { fingerprint as bundleFingerprint } from '../bundle/fingerprint'
 
 const description = 'Analyze a specific task and generate detailed fingerprint without bundling'
 
@@ -26,21 +20,7 @@ const boundaries = {
     return process.cwd()
   },
   loadConf: loadConf.asBoundary(),
-  readFile: async (filePath: string): Promise<string> => {
-    return fs.readFile(filePath, 'utf-8')
-  },
-  writeFile: async (filePath: string, content: string): Promise<void> => {
-    return fs.writeFile(filePath, content)
-  },
-  ensureForgeFolder: async (): Promise<string> => {
-    const forgePath = path.join(os.homedir(), '.forge')
-    try {
-      await fs.access(forgePath)
-    } catch {
-      await fs.mkdir(forgePath, { recursive: true })
-    }
-    return forgePath
-  }
+  bundleFingerprint: bundleFingerprint.asBoundary()
 }
 
 export const fingerprint = createTask({
@@ -49,9 +29,7 @@ export const fingerprint = createTask({
   fn: async function ({ descriptorName }, {
     getCwd,
     loadConf,
-    readFile,
-    writeFile,
-    ensureForgeFolder
+    bundleFingerprint
   }) {
     const cwd = await getCwd()
     const forgeJson = await loadConf({})
@@ -63,37 +41,30 @@ export const fingerprint = createTask({
     }
 
     const filePath = path.join(cwd, taskDescriptor.path)
-    const forgePath = await ensureForgeFolder()
-    const fingerprintFile = path.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 = analyzeTaskFile(sourceCode, filePath)
+    // Use bundle:fingerprint with filePath to analyze the task file directly
+    const result = await bundleFingerprint({
+      descriptorName,
+      filePath
+    })
 
-    if (!taskFingerprint) {
-      throw new Error('Could not extract fingerprint from task file: ' + filePath)
-    }
+    const taskFingerprint = result.taskFingerprint
 
-    // Create analysis result - clean output without extra fields
-    const analysis: FingerprintAnalysis = {
-      taskFingerprint
+    if (!taskFingerprint) {
+      throw new Error('Could not extract fingerprint from task file')
     }
 
-    // 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/src/tasks/task/publish.ts

@@ -14,8 +14,10 @@ import { load as loadConf } from '../conf/load'
 import { create as bundleCreate } from '../bundle/create'
 import { load as bundleLoad } from '../bundle/load'
 import { zip as bundleZip } from '../bundle/zip'
+import { fingerprint as bundleFingerprint } from '../bundle/fingerprint'
 import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
 import { Profile } from '../types'
+import { TaskFingerprintOutput } from '../../utils/taskAnalysis'
 
 const schema = new Schema({
   descriptorName: Schema.string()
@@ -30,14 +32,14 @@ const boundaries = {
   bundleCreate: bundleCreate.asBoundary(),
   bundleLoad: bundleLoad.asBoundary(),
   bundleZip: bundleZip.asBoundary(),
+  bundleFingerprint: bundleFingerprint.asBoundary(),
   readFileUtf8: async (filePath: string): Promise<string> => {
     return fs.readFile(filePath, 'utf-8')
   },
   readFileBinary: async (filePath: string): Promise<Buffer> => {
     return fs.readFile(filePath)
   },
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  publishTask: async (data: any, profile: Profile): Promise<any> => {
+  publishTask: async (data: Record<string, unknown>, profile: Profile): Promise<{ bundleUploadUrl?: string }> => {
     const publishUrl = `${profile.url}/api/tasks/publish`
     const authToken = `${profile.apiKey}:${profile.apiSecret}`
 
@@ -50,17 +52,18 @@ const boundaries = {
       })
 
       return response.data
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    } catch (error: any) {
-      if (error.response?.data?.error.includes('Bundle size')) {
-        throw new Error('Bundle size exceeds the maximum allowed size of 25MB')
+    } catch (error: unknown) {
+      if (error && typeof error === 'object' && 'response' in error) {
+        const axiosError = error as { response?: { data?: { error?: string } } }
+        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: string, bundleContent: Buffer): Promise<any> => {
+  uploadBundleWithPresignedUrl: async (presignedUrl: string, bundleContent: Buffer): Promise<boolean> => {
     const response = await axios.put(presignedUrl, bundleContent, {
       headers: {
         'Content-Type': 'application/octet-stream'
@@ -91,6 +94,7 @@ export const publish = createTask({
     bundleCreate,
     bundleLoad,
     bundleZip,
+    bundleFingerprint,
     readFileUtf8,
     readFileBinary,
     publishTask,
@@ -130,6 +134,25 @@ export const publish = createTask({
 
     console.log('Bundle zipped...')
 
+    // Generate task fingerprint
+    console.log('Generating task fingerprint...')
+    let taskFingerprintData: TaskFingerprintOutput | null = 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
@@ -161,7 +184,8 @@ export const publish = createTask({
       schemaDescriptor: JSON.stringify(schemaDescriptor),
       boundaries,
       sourceCode,
-      bundleSize
+      bundleSize,
+      ...(taskFingerprintData && { fingerprint: taskFingerprintData })
     }
 
     // Publish metadata to hive api server
@@ -178,7 +202,8 @@ export const publish = createTask({
 
       return {
         descriptor: taskDescriptor,
-        publish: true
+        publish: true,
+        fingerprint: taskFingerprintData !== null
       }
     } else {
       throw new Error('Bundle upload failed')

package/src/tasks/types.ts

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