@forgehive/forge-cli 0.2.13 → 0.3.0

package/src/runner.ts

@@ -12,13 +12,16 @@ import { info } from './tasks/conf/info'
 import { createTaskCommand } from './tasks/task/createTask'
 import { run as taskRunCommand } from './tasks/task/run'
 import { remove as taskRemoveCommand } from './tasks/task/remove'
+import { publish as publishTask } from './tasks/task/publish'
+import { download as downloadTask } from './tasks/task/download'
+import { replay as replayTask } from './tasks/task/replay'
+import { list as listTasks } from './tasks/task/list'
+import { describe as describeTask } from './tasks/task/describe'
+import { fingerprint as fingerprintTask } from './tasks/task/fingerprint'
 
 import { create as createRunner } from './tasks/runner/create'
 import { remove as removeRunner } from './tasks/runner/remove'
 import { bundle as bundleRunner } from './tasks/runner/bundle'
-import { publish as publishTask } from './tasks/task/publish'
-import { download as downloadTask } from './tasks/task/download'
-import { replay as replayTask } from './tasks/task/replay'
 
 import { download as downloadFixture } from './tasks/fixture/download'
 
@@ -52,6 +55,9 @@ runner.load('task:remove', taskRemoveCommand)
 runner.load('task:publish', publishTask)
 runner.load('task:download', downloadTask)
 runner.load('task:replay', replayTask)
+runner.load('task:list', listTasks)
+runner.load('task:describe', describeTask)
+runner.load('task:fingerprint', fingerprintTask)
 
 // Runner commands
 runner.load('runner:create', createRunner)
@@ -85,11 +91,10 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
   try {
     let result
 
-    const commandsWithDescriptor = ['task:create', 'task:remove', 'task:publish']
+    const commandsWithDescriptor = ['task:create', 'task:remove', 'task:publish', 'task:describe', 'task:fingerprint']
     const commandsWithRunner = ['runner:create', 'runner:remove']
 
     if (commandsWithDescriptor.includes(taskName)) {
-      console.log('Running:', taskName, action)
       result = await task.run({ descriptorName: action })
     } else if (commandsWithRunner.includes(taskName)) {
       result = await task.run({
@@ -147,6 +152,10 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
       result = await task.run(args)
     }
 
+    if (taskName === 'task:describe' || taskName === 'task:list') {
+      silent = true
+    }
+
     return {
       silent,
       outcome: 'Success',

package/src/tasks/README.md

@@ -1,6 +1,6 @@
-# Shadow CLI Task Guidelines
+# Forge CLI Task Guidelines
 
-This document outlines the standard patterns and best practices for creating tasks in the Shadow CLI.
+This document outlines the standard patterns and best practices for creating tasks in the Forge CLI.
 
 ## Task Structure
 
@@ -9,10 +9,10 @@ All tasks should follow this standard structure:
 ```typescript
 // TASK: [task_name]
 // Run this task with:
-// shadow-cli [namespace]:[task_name]
+// forge task:run [namespace]:[task_name]
 
-import { createTask } from '@shadow/task'
-import { Schema } from '@shadow/schema'
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
 // Import any additional dependencies
 
 // Define the schema for task arguments
@@ -33,7 +33,7 @@ export const taskName = createTask(
   boundaries,
   async function ({ /* destructured parameters */ }) {
     // Task implementation
-    
+
     // Return appropriate result
     return result
   }
@@ -45,8 +45,8 @@ export const taskName = createTask(
 ### Bundle Creation Task
 
 ```typescript
-import { createTask } from '@shadow/task'
-import { Schema } from '@shadow/schema'
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
 import esbuild from 'esbuild'
 
 const schema = new Schema({
@@ -80,8 +80,8 @@ export const create = createTask(
 ### Bundle Loading Task
 
 ```typescript
-import { createTask } from '@shadow/task'
-import { Schema } from '@shadow/schema'
+import { createTask } from '@forgehive/task'
+import { Schema } from '@forgehive/schema'
 
 const schema = new Schema({
   bundlePath: Schema.string()
@@ -129,11 +129,11 @@ Common schema types include:
 Tasks can be run using the CLI:
 
 ```bash
-shadow-cli [namespace]:[task_name] --paramName=value
+forge task:run [namespace]:[task_name] --paramName=value
 ```
 
 For example:
 
 ```bash
-shadow-cli bundle:create --entryPoint=src/index.ts --outputFile=dist/bundle.js
-``` 
+forge task:run bundle:create --entryPoint=src/index.ts --outputFile=dist/bundle.js
+```

package/src/tasks/auth/add.ts

@@ -27,10 +27,10 @@ const boundaries = {
   }
 }
 
-export const add = createTask(
+export const add = createTask({
   schema,
   boundaries,
-  async function ({ name, apiKey, apiSecret, url }, { loadProfiles, persistProfiles }) {
+  fn: async function ({ name, apiKey, apiSecret, url }, { loadProfiles, persistProfiles }) {
     const profiles = await loadProfiles({})
 
     // Check if profile with same name already exists
@@ -54,4 +54,4 @@ export const add = createTask(
       message: `Profile '${name}' added and set as default`
     }
   }
-)
+})

package/src/tasks/auth/list.ts

@@ -14,10 +14,10 @@ const boundaries = {
   loadProfiles: loadProfiles.asBoundary()
 }
 
-export const list = createTask(
+export const list = createTask({
   schema,
   boundaries,
-  async function (_argv, { loadProfiles }) {
+  fn: async function (_argv, { loadProfiles }) {
     const profiles: Profiles = await loadProfiles({})
 
     if (profiles.profiles.length === 0) {
@@ -40,4 +40,4 @@ export const list = createTask(
       default: profiles.default
     }
   }
-)
+})

package/src/tasks/auth/load.ts

@@ -26,10 +26,10 @@ const boundaries = {
   }
 }
 
-export const load = createTask(
+export const load = createTask({
   schema,
   boundaries,
-  async function (argv, { ensureBuildsFolder }) {
+  fn: async function (argv, { ensureBuildsFolder }) {
     const buildsPath = await ensureBuildsFolder()
 
     let profiles: Profiles = {
@@ -48,4 +48,4 @@ export const load = createTask(
 
     return profiles
   }
-)
+})

package/src/tasks/auth/loadCurrent.ts

@@ -14,10 +14,10 @@ const boundaries = {
   loadProfiles: loadProfiles.asBoundary()
 }
 
-export const loadCurrent = createTask(
+export const loadCurrent = createTask({
   schema,
   boundaries,
-  async function (_argv, { loadProfiles }): Promise<Profile> {
+  fn: async function (_argv, { loadProfiles }): Promise<Profile> {
     const profiles = await loadProfiles({})
 
     if (!profiles.default || profiles.default === '') {
@@ -32,4 +32,4 @@ export const loadCurrent = createTask(
 
     return { ...defaultProfile, name: profiles.default }
   }
-)
+})

package/src/tasks/auth/remove.ts

@@ -24,10 +24,10 @@ const boundaries = {
   }
 }
 
-export const remove = createTask(
+export const remove = createTask({
   schema,
   boundaries,
-  async function ({ profileName }, { loadProfiles, persistProfiles }) {
+  fn: async function ({ profileName }, { loadProfiles, persistProfiles }) {
     const profiles = await loadProfiles({})
 
     // Check if profile exists
@@ -63,4 +63,4 @@ export const remove = createTask(
       message: `Profile "${profileName}" has been removed.`
     }
   }
-)
+})

package/src/tasks/auth/switch.ts

@@ -24,10 +24,10 @@ const boundaries = {
   }
 }
 
-export const switchProfile = createTask(
+export const switchProfile = createTask({
   schema,
   boundaries,
-  async function ({ profileName }, { loadProfiles, persistProfiles }) {
+  fn: async function ({ profileName }, { loadProfiles, persistProfiles }) {
     // Load profiles
     const profiles = await loadProfiles({})
 
@@ -50,4 +50,4 @@ export const switchProfile = createTask(
       default: profileName
     }
   }
-)
+})

package/src/tasks/bundle/README.md

@@ -17,7 +17,7 @@ Creates a bundled JavaScript file using esbuild.
 
 **Example Usage:**
 ```bash
-shadow-cli bundle:create --entryPoint=src/index.ts --outputFile=dist/bundle.js
+forge task:run bundle:create --entryPoint=src/index.ts --outputFile=dist/bundle.js
 ```
 
 **Implementation Details:**
@@ -38,7 +38,7 @@ Dynamically loads a JavaScript bundle and returns its default export.
 
 **Example Usage:**
 ```bash
-shadow-cli bundle:load --bundlePath=dist/bundle.js
+forge task:run bundle:load --bundlePath=dist/bundle.js
 ```
 
 **Implementation Details:**
@@ -51,10 +51,10 @@ shadow-cli bundle:load --bundlePath=dist/bundle.js
 
 ```bash
 # First, create the bundle
-shadow-cli bundle:create --entryPoint=src/index.ts --outputFile=dist/bundle.js
+forge task:run bundle:create --entryPoint=src/index.ts --outputFile=dist/bundle.js
 
 # Then, load the bundle
-shadow-cli bundle:load --bundlePath=dist/bundle.js
+forge task:run bundle:load --bundlePath=dist/bundle.js
 ```
 
 ### Using in Scripts
@@ -71,13 +71,13 @@ async function buildAndLoad() {
     entryPoint: 'src/index.ts',
     outputFile: 'dist/bundle.js'
   })
-  
+
   // Load bundle
   const bundleExport = await loadBundle({
     bundlePath: 'dist/bundle.js'
   })
-  
+
   // Use the loaded bundle
   return bundleExport
 }
-``` 
+```

package/src/tasks/bundle/create.ts

@@ -1,6 +1,6 @@
 // TASK: create
 // Run this task with:
-// shadow-cli bundle:create
+// forge task:run bundle:create
 
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
@@ -13,10 +13,10 @@ const schema = new Schema({
 
 const boundaries = {}
 
-export const create = createTask(
+export const create = createTask({
   schema,
   boundaries,
-  async function ({ entryPoint, outputFile }) {
+  fn: async function ({ entryPoint, outputFile }) {
     // Build using esbuild
     await esbuild.build({
       entryPoints: [entryPoint],
@@ -29,4 +29,4 @@ export const create = createTask(
 
     return { outputFile }
   }
-)
+})

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`)
     }
   }
-)
+})