@forgehive/forge-cli 0.2.14 → 0.3.1

package/src/tasks/bundle/fingerprint.ts

@@ -0,0 +1,218 @@
+// TASK: fingerprint
+// Run this task with:
+// forge task:run bundle:fingerprint --descriptorName task-name
+
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
+import esbuild from 'esbuild'
+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 TaskFingerprint {
+  name: string
+  description?: string
+  location: {
+    file: string
+    line: number
+    column: number
+  }
+  inputSchema: TaskFingerprintOutput['inputSchema']
+  outputType: TaskFingerprintOutput['outputType']
+  boundaries: string[]
+  hash: string
+}
+
+interface EsbuildResultWithFingerprints extends esbuild.BuildResult {
+  fingerprints?: TaskFingerprint[]
+}
+
+interface FingerprintResult {
+  tasks: TaskFingerprintOutput[]
+  buildInfo: {
+    entryPoint: string
+    outputFile: string
+    fingerprintsFile?: string
+    totalTasks: number
+    buildTimestamp: string
+  }
+}
+
+const description = 'Generate task bundle with comprehensive fingerprinting and type extraction'
+
+const schema = new Schema({
+  descriptorName: Schema.string(),
+  filePath: Schema.string().optional()
+})
+
+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
+  }
+}
+
+// esbuild plugin for fingerprinting
+function taskFingerprintPlugin(): esbuild.Plugin {
+  return {
+    name: 'task-fingerprint',
+    setup(build): void {
+      const fingerprints: TaskFingerprint[] = []
+
+      build.onLoad({ filter: /\.ts$/ }, async (args) => {
+        const sourceCode = await fs.readFile(args.path, 'utf-8')
+
+        // Only analyze files that contain createTask
+        if (sourceCode.includes('createTask')) {
+          const taskFingerprint = analyzeTaskFile(sourceCode, args.path)
+          if (taskFingerprint) {
+            // Convert to full TaskFingerprint for plugin compatibility
+            const fullFingerprint: TaskFingerprint = {
+              name: path.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): void => {
+        // Store fingerprints for later use
+        (result as EsbuildResultWithFingerprints).fingerprints = fingerprints
+      })
+    }
+  }
+}
+
+export const fingerprint = 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 = 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 as keyof typeof forgeJson.tasks]
+
+    if (taskDescriptor === undefined) {
+      throw new Error(`Task "${descriptorName}" is not defined in forge.json`)
+    }
+
+    const entryPoint = path.join(cwd, taskDescriptor.path)
+    const forgePath = await ensureForgeFolder()
+    const outputFile = path.join(forgePath, `${descriptorName}.js`)
+    const fingerprintsFile = path.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.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 as EsbuildResultWithFingerprints).fingerprints || []
+
+    // Convert to simplified output format (remove name, location, hash)
+    const simplifiedFingerprints: TaskFingerprintOutput[] = taskFingerprints.map((fp: TaskFingerprint) => ({
+      description: fp.description,
+      inputSchema: fp.inputSchema,
+      outputType: fp.outputType,
+      boundaries: fp.boundaries
+    }))
+
+    // Create fingerprint result
+    const fingerprintResult: 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: TaskFingerprint) => ({
+          name: fp.name,
+          inputType: fp.inputSchema.type,
+          outputType: fp.outputType.type,
+          boundaryCount: fp.boundaries.length,
+          hash: fp.hash
+        }))
+      }
+    }
+  }
+})
+
+fingerprint.setDescription(description)

package/src/tasks/bundle/load.ts

@@ -1,6 +1,6 @@
 // TASK: load
 // Run this task with:
-// shadow-cli bundle:load
+// forge task:run bundle:load
 
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
@@ -11,13 +11,13 @@ const schema = new Schema({
 
 const boundaries = {}
 
-export const load = createTask(
+export const load = createTask({
   schema,
   boundaries,
-  async function ({ bundlePath }) {
+  fn: async function ({ bundlePath }) {
     // Dynamically import the bundle from the specified path
     const bundle = await import(bundlePath)
 
     return bundle
   }
-)
+})

package/src/tasks/bundle/zip.ts

@@ -41,10 +41,10 @@ export const bytesToMB = (bytes: number): string => {
   return `${MB.toFixed(2)} MB`
 }
 
-export const zip = createTask(
+export const zip = createTask({
   schema,
   boundaries,
-  async function ({ dir, input, output }, { createWriteStream, createArchiver, resolvePathDir, fileExists }) {
+  fn: async function ({ dir, input, output }, { createWriteStream, createArchiver, resolvePathDir, fileExists }) {
     const outputPath = await resolvePathDir(dir, output)
     const inputPath = await resolvePathDir(dir, input)
     const inputMapPath = inputPath + '.map'
@@ -104,6 +104,6 @@ export const zip = createTask(
       archive.finalize()
     })
   }
-)
+})
 
 zip.setDescription(description)

package/src/tasks/conf/info.ts

@@ -16,10 +16,10 @@ const boundaries = {
   loadCurrentProfile: loadCurrentProfile.asBoundary()
 }
 
-export const info = createTask(
+export const info = createTask({
   schema,
   boundaries,
-  async function (_argv, { loadCurrentProfile, readFile }) {
+  fn: async function (_argv, { loadCurrentProfile, readFile }) {
     const packageJsonPath = path.join(__dirname, '../../../package.json')
 
     const packageJsonContent = await readFile(packageJsonPath)
@@ -45,4 +45,4 @@ export const info = createTask(
 
     return info
   }
-)
+})

package/src/tasks/conf/load.ts

@@ -14,13 +14,13 @@ const boundaries = {
   }
 }
 
-export const load = createTask(
+export const load = createTask({
   schema,
   boundaries,
-  async function (_, { readFile }) {
+  fn: async function (_, { readFile }) {
     const forgePath = path.join(process.cwd(), 'forge.json')
 
     const content = await readFile(forgePath)
     return JSON.parse(content) as ForgeConf
   }
-)
+})

package/src/tasks/fixture/download.ts

@@ -62,10 +62,10 @@ const boundaries = {
   }
 }
 
-export const download = createTask(
+export const download = createTask({
   schema,
   boundaries,
-  async function ({ uuid }, {
+  fn: async function ({ uuid }, {
     downloadFixture,
     getCwd,
     persistFixture,
@@ -131,6 +131,6 @@ forge task:replay ${taskName} --path ${shortPath}
       shortPath: shortPath
     }
   }
-)
+})
 
 download.setDescription(description)

package/src/tasks/init.ts

@@ -20,10 +20,10 @@ const boundaries = {
 }
 
 // Create a task with type inference from schema and boundaries
-export const init = createTask(
+export const init = createTask({
   schema,
   boundaries,
-  async function (argv, { saveFile, getCwd }) {
+  fn: async function (argv, { saveFile, getCwd }) {
     // Handle the dryRun flag
     const isDryRun = Boolean(argv.dryRun)
 
@@ -60,4 +60,4 @@ export const init = createTask(
 
     return config
   }
-)
+})

package/src/tasks/runner/bundle.ts

@@ -29,10 +29,10 @@ const boundaries = {
   }
 }
 
-export const bundle = createTask(
+export const bundle = createTask({
   schema,
   boundaries,
-  async function ({ runnerName, targetPath }, { loadConf, getCwd, ensureDir }) {
+  fn: async function ({ runnerName, targetPath }, { loadConf, getCwd, ensureDir }) {
     // Load forge configuration
     const forge: ForgeConf = await loadConf({})
     const cwd = await getCwd()
@@ -76,4 +76,4 @@ export const bundle = createTask(
       outputFile: path.join(targetPath, `${runnerName}.js`)
     }
   }
-)
+})

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

@@ -36,10 +36,10 @@ const boundaries = {
   }
 }
 
-export const describe = createTask(
+export const describe = createTask({
   schema,
   boundaries,
-  async function ({ descriptorName }, {
+  fn: async function ({ descriptorName }, {
     loadConf,
     bundleCreate,
     bundleLoad,
@@ -143,6 +143,6 @@ export const describe = createTask(
       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

@@ -18,10 +18,10 @@ const boundaries = {
   loadConf: loadConf.asBoundary()
 }
 
-export const list = createTask(
+export const list = createTask({
   schema,
   boundaries,
-  async function (argv, { loadConf }) {
+  fn: async function (argv, { loadConf }) {
     // Load forge configuration
     const forge: ForgeConf = await loadConf({})
 
@@ -53,6 +53,6 @@ export const list = createTask(
       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)