@forgehive/forge-cli 0.2.13 → 0.3.0

package/src/tasks/runner/create.ts

@@ -69,10 +69,10 @@ const boundaries = {
   }
 }
 
-export const create = createTask(
+export const create = createTask({
   schema,
   boundaries,
-  async function ({ runnerName }, {
+  fn: async function ({ runnerName }, {
     persistRunner,
     loadConf,
     persistConf,
@@ -118,4 +118,4 @@ export const create = createTask(
       runnerName: formattedName
     }
   }
-)
+})

package/src/tasks/runner/remove.ts

@@ -32,10 +32,10 @@ const boundaries = {
   }
 }
 
-export const remove = createTask(
+export const remove = createTask({
   schema,
   boundaries,
-  async function ({ runnerName }, {
+  fn: async function ({ runnerName }, {
     loadConf,
     getCwd,
     removeRunner,
@@ -71,4 +71,4 @@ export const remove = createTask(
       runnerName: formattedName
     }
   }
-)
+})

package/src/tasks/task/createTask.ts

@@ -18,6 +18,7 @@ const TASK_TEMPLATE = `// TASK: {{ taskName }}
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
 
+const name = '{{ taskDescriptor }}'
 const description = 'Add task description here'
 
 const schema = new Schema({
@@ -30,10 +31,12 @@ const boundaries = {
   // example: readFile: async (path: string) => fs.readFile(path, 'utf-8')
 }
 
-export const {{ taskName }} = createTask(
+export const {{ taskName }} = 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
@@ -41,9 +44,8 @@ export const {{ taskName }} = createTask(
 
     return status
   }
-)
+})
 
-{{ taskName }}.setDescription(description)
 `
 
 const schema = new Schema({
@@ -107,10 +109,10 @@ const boundaries = {
   }
 }
 
-export const createTaskCommand = createTask(
+export const createTaskCommand = createTask({
   schema,
   boundaries,
-  async function ({ descriptorName }, {
+  fn: async function ({ descriptorName }, {
     loadTemplate,
     persistTask,
     loadConf,
@@ -132,6 +134,7 @@ export const createTaskCommand = createTask(
     ==================================================
     Starting task creation!
     Creating: ${taskName}
+    Descriptor: ${descriptor}
     Dir:  ${dir ?? ''}
     Into: ${taskPath}
     ==================================================
@@ -159,4 +162,4 @@ export const createTaskCommand = createTask(
 
     return { taskPath, fileName }
   }
-)
+})

package/src/tasks/task/describe.ts

@@ -0,0 +1,148 @@
+// TASK: describe
+// Run this task with:
+// forge task:run task:describe
+
+import path from 'path'
+import os from 'os'
+import fs from 'fs/promises'
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+
+import { create as bundleCreate } from '../bundle/create'
+import { load as bundleLoad } from '../bundle/load'
+import { load as loadConf } from '../conf/load'
+import { type ForgeConf } from '../types'
+
+const description = 'Describe a task with detailed information about its schema, boundaries and configuration'
+
+const schema = new Schema({
+  descriptorName: Schema.string()
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary(),
+  bundleCreate: bundleCreate.asBoundary(),
+  bundleLoad: bundleLoad.asBoundary(),
+  ensureBuildsFolder: async (): Promise<string> => {
+    const buildsPath = path.join(os.homedir(), '.forge', 'builds')
+    try {
+      await fs.access(buildsPath)
+    } catch {
+      await fs.mkdir(buildsPath, { recursive: true })
+    }
+
+    return buildsPath
+  }
+}
+
+export const describe = createTask({
+  schema,
+  boundaries,
+  fn: async function ({ descriptorName }, {
+    loadConf,
+    bundleCreate,
+    bundleLoad,
+    ensureBuildsFolder
+  }) {
+    // Load forge configuration
+    const forge: ForgeConf = await loadConf({})
+    const taskDescriptor = forge.tasks[descriptorName as keyof typeof forge.tasks]
+
+    if (taskDescriptor === undefined) {
+      throw new Error(`Task "${descriptorName}" is not defined in forge.json`)
+    }
+
+    // Prepare paths
+    const entryPoint = path.join(process.cwd(), taskDescriptor.path)
+    const buildsPath = await ensureBuildsFolder()
+    const outputFile = path.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 {
+      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')
+      } else {
+        boundaryKeys.forEach(boundaryName => {
+          console.log(`  • ${boundaryName}`)
+        })
+      }
+    } 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) : []
+    }
+  }
+})
+
+describe.setDescription(description)

package/src/tasks/task/download.ts

@@ -90,10 +90,10 @@ const boundaries = {
   }
 }
 
-export const download = createTask(
+export const download = createTask({
   schema,
   boundaries,
-  async function ({ descriptorName, uuid }, {
+  fn: async function ({ descriptorName, uuid }, {
     downloadTask,
     getCwd,
     parseTaskName,
@@ -189,4 +189,4 @@ export const download = createTask(
       handler: response.handler
     }
   }
-)
+})

package/src/tasks/task/fingerprint.ts

@@ -0,0 +1,107 @@
+// TASK: fingerprint
+// Run this task with:
+// forge task:run task:fingerprint --descriptorName task-name
+
+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
+}
+
+const description = 'Analyze a specific task and generate detailed fingerprint without bundling'
+
+const schema = new Schema({
+  descriptorName: Schema.string()
+})
+
+const boundaries = {
+  getCwd: async (): Promise<string> => {
+    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
+  }
+}
+
+export const fingerprint = 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 as keyof typeof forgeJson.tasks]
+
+    if (taskDescriptor === undefined) {
+      throw new Error(`Task "${descriptorName}" is not defined in forge.json`)
+    }
+
+    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)
+
+    if (!taskFingerprint) {
+      throw new Error('Could not extract fingerprint from task file: ' + filePath)
+    }
+
+    // Create analysis result - clean output without extra fields
+    const analysis: FingerprintAnalysis = {
+      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
+      }
+    }
+  }
+})
+
+fingerprint.setDescription(description)

package/src/tasks/task/list.ts

@@ -0,0 +1,58 @@
+// TASK: list
+// Run this task with:
+// forge task:run task:list
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+
+import { load as loadConf } from '../conf/load'
+import { type ForgeConf } from '../types'
+
+const description = 'List all available tasks in the current project'
+
+const schema = new Schema({
+  // No arguments needed
+})
+
+const boundaries = {
+  loadConf: loadConf.asBoundary()
+}
+
+export const list = createTask({
+  schema,
+  boundaries,
+  fn: async function (argv, { loadConf }) {
+    // Load forge configuration
+    const forge: ForgeConf = 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
+    }
+  }
+})
+
+list.setDescription(description)

package/src/tasks/task/publish.ts

@@ -81,10 +81,10 @@ const boundaries = {
   }
 }
 
-export const publish = createTask(
+export const publish = createTask({
   schema,
   boundaries,
-  async function ({ descriptorName }, {
+  fn: async function ({ descriptorName }, {
     getCwd,
     ensureBuildsFolder,
     loadConf,
@@ -184,4 +184,4 @@ export const publish = createTask(
       throw new Error('Bundle upload failed')
     }
   }
-)
+})

package/src/tasks/task/remove.ts

@@ -25,10 +25,10 @@ const boundaries = {
   }
 }
 
-export const remove = createTask(
+export const remove = createTask({
   schema,
   boundaries,
-  async function ({ descriptorName }, { loadConf, persistConf, deleteFile }) {
+  fn: async function ({ descriptorName }, { loadConf, persistConf, deleteFile }) {
     // Load shadow configuration
     const forge: ForgeConf = await loadConf({})
 
@@ -61,4 +61,4 @@ export const remove = createTask(
       message: `Task '${descriptorName}' has been successfully removed`
     }
   }
-)
+})

package/src/tasks/task/replay.ts

@@ -96,10 +96,10 @@ const boundaries = {
   }
 }
 
-export const replay = createTask(
+export const replay = createTask({
   schema,
   boundaries,
-  async function ({ descriptorName, path: fixturePath, cache }, { readFixture, loadConf, loadCurrentProfile, bundleCreate, bundleLoad, ensureBuildsFolder, verifyLogFolder, sendLogToAPI }) {
+  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)
@@ -215,6 +215,6 @@ export const replay = createTask(
 
     return result
   }
-)
+})
 
 replay.setDescription(description)

package/src/tasks/task/run.ts

@@ -1,6 +1,7 @@
 // TASK: run
 // Run this task with:
-// shadow-cli task:run
+// most recursive call on the project
+// forge task:run task:run
 
 import path from 'path'
 import fs from 'fs/promises'
@@ -78,10 +79,10 @@ const boundaries = {
   }
 }
 
-export const run = createTask(
+export const run = createTask({
   schema,
   boundaries,
-  async function ({ descriptorName, args }, {
+  fn: async function ({ descriptorName, args }, {
     loadConf,
     bundleCreate,
     bundleLoad,
@@ -187,4 +188,4 @@ export const run = createTask(
 
     return result
   }
-)
+})

package/src/test/setup.ts

@@ -0,0 +1,14 @@
+// Global test setup - mocks for problematic ES modules
+
+// Mock archiver to avoid ES module issues
+jest.mock('archiver', () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    pipe: jest.fn(),
+    finalize: jest.fn(),
+    directory: jest.fn(),
+    file: jest.fn(),
+    on: jest.fn(),
+    pointer: jest.fn(() => 0)
+  }))
+}))

package/src/test/tasks/create.test.ts

@@ -1,5 +1,5 @@
 import { createTaskCommand } from '../../tasks/task/createTask'
-import { createFsFromVolume, Volume } from 'memfs'
+import { createFsFromVolume, Volume, type IFs } from 'memfs'
 import path from 'path'
 import { createMockBoundary } from '../testUtils'
 import { ForgeConf } from '../../tasks/types'
@@ -12,6 +12,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({
@@ -24,10 +25,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
@@ -35,15 +38,13 @@ export const newTask = createTask(
 
     return status
   }
-)
+})
 
-newTask.setDescription(description)
 `
 
 describe('Create task', () => {
   let volume: InstanceType<typeof Volume>
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let fs: any
+  let fs: IFs
   let rootDir: string
 
   beforeEach(() => {
@@ -96,11 +97,10 @@ describe('Create task', () => {
 
     // Read the created task file
     const fileContent = await fs.promises.readFile(path.join(rootDir, 'src/tasks/sample', 'newTask.ts'), 'utf-8')
-
     expect(fileContent).toBe(expectedContent)
 
     // Read the updated forge.json
-    const forgeContent = await fs.promises.readFile(path.join(rootDir, 'forge.json'), 'utf-8')
+    const forgeContent = await fs.promises.readFile(path.join(rootDir, 'forge.json'), 'utf-8') as string
     const forgeConf = JSON.parse(forgeContent)
     expect(forgeConf.tasks['sample:newTask']).toBeDefined()
   })