@forgehive/forge-cli 0.3.17 → 0.5.1

package/src/tasks/task/describe.ts

@@ -17,7 +17,7 @@ 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()
+  descriptorName: Schema.string().describe('The task descriptor name to describe (e.g. domain:taskName)')
 })
 
 const boundaries = {

package/src/tasks/task/download.ts

@@ -13,8 +13,8 @@ import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
 import { Profile, type ForgeConf } from '../types'
 
 const schema = new Schema({
-  descriptorName: Schema.string(),
-  uuid: Schema.string()
+  descriptorName: Schema.string().describe('The task descriptor name (e.g. domain:taskName)'),
+  uuid: Schema.string().describe('The UUID of the task version to download')
 })
 
 const boundaries = {

package/src/tasks/task/fingerprint.ts

@@ -12,7 +12,7 @@ import { fingerprint as bundleFingerprint } from '../bundle/fingerprint'
 const description = 'Analyze a specific task and generate detailed fingerprint without bundling'
 
 const schema = new Schema({
-  descriptorName: Schema.string()
+  descriptorName: Schema.string().describe('The task descriptor name to fingerprint (e.g. domain:taskName)')
 })
 
 const boundaries = {

package/src/tasks/task/invoke.ts

@@ -14,8 +14,8 @@ const name = 'task:invoke'
 const description = 'Invoke a deployed task remotely using the Hive API'
 
 const schema = new Schema({
-  descriptorName: Schema.string(),
-  json: Schema.string()
+  descriptorName: Schema.string().describe('The task descriptor name (e.g. domain:taskName)'),
+  json: Schema.string().describe('JSON string of arguments to pass to the task')
 })
 
 const boundaries = {

package/src/tasks/task/publish.ts

@@ -20,7 +20,7 @@ import { Profile } from '../types'
 import { TaskFingerprintOutput } from '../../utils/taskAnalysis'
 
 const schema = new Schema({
-  descriptorName: Schema.string()
+  descriptorName: Schema.string().describe('The task descriptor name to publish (e.g. domain:taskName)')
 })
 
 const boundaries = {

package/src/tasks/task/remove.ts

@@ -11,7 +11,7 @@ import { load } from '../conf/load'
 import { type ForgeConf } from '../types'
 
 const schema = new Schema({
-  descriptorName: Schema.string()
+  descriptorName: Schema.string().describe('The task descriptor name to remove (e.g. domain:taskName)')
 })
 
 const boundaries = {

package/src/tasks/task/replay.ts

@@ -7,8 +7,8 @@ import { Schema } from '@forgehive/schema'
 import fs from 'fs/promises'
 import path from 'path'
 import os from 'os'
-import axios from 'axios'
 
+import { createClientFromForgeConf, type ExecutionRecord } from '@forgehive/hive-sdk'
 import { create as bundleCreate } from '../bundle/create'
 import { load as bundleLoad } from '../bundle/load'
 import { load as loadConf } from '../conf/load'
@@ -30,9 +30,9 @@ interface Fixture {
 const description = 'Replay a task execution from a specified path'
 
 const schema = new Schema({
-  descriptorName: Schema.string(),
-  path: Schema.string(),
-  cache: Schema.string().optional()
+  descriptorName: Schema.string().describe('The task descriptor name to replay (e.g. domain:taskName)'),
+  path: Schema.string().describe('Path to the execution log fixture to replay'),
+  cache: Schema.string().describe('Cache mode for boundaries during replay').optional()
 })
 
 const boundaries = {
@@ -66,32 +66,47 @@ const boundaries = {
 
     return true
   },
-  sendLogToAPI: async (profile: Profile, projectName: string, taskName: string, logItem: unknown, fixtureUUID: string): Promise<boolean> => {
+  sendLogToAPI: async (
+    profile: Profile,
+    record: ExecutionRecord,
+    fixtureUUID: string
+  ): Promise<{ success: boolean; logUuid?: string }> => {
     try {
-      const logsUrl = `${profile.url}/api/tasks/log-ingest`
-      const authToken = `${profile.apiKey}:${profile.apiSecret}`
-
-      await axios.post(logsUrl, {
-        projectName,
-        taskName,
-        logItem: JSON.stringify(logItem),
-        replayFrom: fixtureUUID
-      }, {
-        headers: {
-          Authorization: `Bearer ${authToken}`,
-          'Content-Type': 'application/json'
+      // Use createClientFromForgeConf to automatically load forge.json with task UUIDs
+      const client = createClientFromForgeConf('./forge.json', {
+        apiKey: profile.apiKey,
+        apiSecret: profile.apiSecret,
+        host: profile.url,
+        metadata: {
+          environment: 'cli',
+          replayFrom: fixtureUUID
         }
       })
 
       console.log('===============================================')
-      console.log('Log sent to API... ', profile.name, profile.url)
-      console.log('Replay from fixture UUID:', fixtureUUID)
+      console.log('Sending replay log to Hive...')
+      const result = await client.sendLog(record)
 
-      return true
+      if (result === 'success' || (typeof result === 'object' && 'uuid' in result)) {
+        console.log('✅ Log sent to API...', profile.name, profile.url)
+        console.log('Replay from fixture UUID:', fixtureUUID)
+        console.log('===============================================')
+
+        if (typeof result === 'object' && result && 'uuid' in result) {
+          return { success: true, logUuid: result.uuid }
+        }
+
+        return { success: true }
+      } else {
+        console.error('❌ Failed to send log to Hive')
+        console.log('===============================================')
+        return { success: false }
+      }
     } catch (e) {
       const error = e as Error
-      console.error('Failed to send log to API:', error.message)
-      return false
+      console.error('❌ Failed to send log to API:', error.message)
+      console.log('===============================================')
+      return { success: false }
     }
   }
 }
@@ -107,7 +122,6 @@ export const replay = createTask({
     // Load forge configuration
     const forge: ForgeConf = await loadConf({})
     const taskDescriptor = forge.tasks[descriptorName as keyof typeof forge.tasks]
-    const projectName = forge.project.name
 
     if (taskDescriptor === undefined) {
       throw new Error(`Task ${descriptorName} is not defined in forge.json`)
@@ -203,7 +217,7 @@ export const replay = createTask({
     // Send the log to API if profile is available
     if (profile) {
       try {
-        await sendLogToAPI(profile, projectName, descriptorName, record, fixture.fixtureUUID)
+        await sendLogToAPI(profile, record, fixture.fixtureUUID)
       } catch (e) {
         console.error('Failed to send log to API:', e)
       }

package/src/tasks/task/run.ts

@@ -10,7 +10,7 @@ import os from 'os'
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
 import { RecordTape } from '@forgehive/record-tape'
-import { HiveLogClient, type ExecutionRecord } from '@forgehive/hive-sdk'
+import { createClientFromForgeConf, type ExecutionRecord } from '@forgehive/hive-sdk'
 
 import { create as bundleCreate } from '../bundle/create'
 import { load as bundleLoad } from '../bundle/load'
@@ -21,8 +21,8 @@ import { type ForgeConf, type Profile } from '../types'
 // For now, we'll use a simple schema without the record type
 // TODO: Use Schema.record once it's properly built and available
 const schema = new Schema({
-  descriptorName: Schema.string(),
-  args: Schema.mixedRecord()
+  descriptorName: Schema.string().describe('The task descriptor name to run (e.g. domain:taskName)'),
+  args: Schema.mixedRecord().describe('Arguments to pass to the task')
   // args will be passed directly without schema validation for now
 })
 
@@ -51,46 +51,37 @@ const boundaries = {
   },
   sendLogToAPI: async (
     profile: Profile,
-    projectName: string,
     record: ExecutionRecord,
-    taskUuid?: string,
-    projectUuid?: string
+    taskUuid?: string
   ): Promise<{ success: boolean; logUuid?: string; taskUuid?: string; skipRemoteLog?: boolean }> => {
-    // Check if we have required UUIDs for the new endpoint
-    if (!projectUuid || !taskUuid) {
+    // Check if we have required UUID for the task
+    if (!taskUuid) {
       console.log('===============================================')
-      console.log('⚠️  Remote logging skipped - missing UUIDs')
+      console.log('⚠️  Remote logging skipped - missing task UUID')
       console.log('')
       console.log('To enable remote logging with enhanced features:')
-      if (!projectUuid) {
-        console.log('• Use "forge project:create" to create a new project, or')
-        console.log('• Use "forge project:link" to connect to an existing project')
-      }
-      if (!taskUuid) {
-        console.log('• Use "forge project:sync" to get the task to have UUID')
-      }
+      console.log('• Use "forge project:sync" to sync tasks and get UUIDs')
       console.log('===============================================')
       return { success: true, skipRemoteLog: true }
     }
 
     try {
-      const config = {
-        projectName,
-        projectUuid,
+      // Use createClientFromForgeConf to automatically load forge.json with task UUIDs
+      const client = createClientFromForgeConf('./forge.json', {
         apiKey: profile.apiKey,
         apiSecret: profile.apiSecret,
         host: profile.url,
         metadata: {
           environment: 'cli'
         }
-      }
+      })
 
-      const client = new HiveLogClient(config)
+      console.log('===============================================')
       console.log('Sending execution log to Hive...')
-      const result = await client.sendLogByUuid(record, taskUuid)
+      const result = await client.sendLog(record)
 
       if (result === 'success' || (typeof result === 'object' && 'uuid' in result)) {
-        console.log('===============================================')
+        console.log('')
         console.log('✅ Log sent to Hive successfully')
         console.log(`   Profile: ${profile.name}`)
         console.log(`   Host: ${profile.url}`)
@@ -102,13 +93,17 @@ const boundaries = {
 
         return { success: true, taskUuid }
       } else {
+        console.log('')
         console.error('❌ Failed to send log to Hive:', profile.url)
+        console.log('===============================================')
         return { success: false }
       }
     } catch (e) {
+      console.log('===============================================')
       console.error('❌ Failed to send log to Hive:', profile.url)
       const error = e as Error
       console.error('Error:', error.message)
+      console.log('===============================================')
       return { success: false }
     }
   }
@@ -129,8 +124,6 @@ export const run = createTask({
     // Load forge configuration
     const forge: ForgeConf = await loadConf({})
     const taskDescriptor = forge.tasks[descriptorName as keyof typeof forge.tasks]
-    const projectName = forge.project.name
-    const projectUuid = forge.project.uuid
     const taskUuid = taskDescriptor?.uuid
 
     if (taskDescriptor === undefined) {
@@ -204,7 +197,7 @@ export const run = createTask({
 
     if (profile) {
       try {
-        const logResult = await sendLogToAPI(profile, projectName, logItem, taskUuid, projectUuid)
+        const logResult = await sendLogToAPI(profile, logItem, taskUuid)
 
         if (logResult.success && !logResult.skipRemoteLog && taskUuid) {
           console.log(`🔗 View execution logs: ${profile.url}/tasks/${taskUuid}?tab=logs`)

package/src/tasks/types.ts

@@ -22,6 +22,7 @@ export interface ForgeConf {
   project: {
     name: string
     uuid?: string
+    description?: string
   }
   paths: {
     logs: string

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

@@ -16,8 +16,9 @@ const name = 'sample:newTask'
 const description = 'Add task description here'
 
 const schema = new Schema({
-  // Add your schema definitions here
-  // example: myParam: Schema.string()
+  // Add your schema definitions here.
+  // Use .describe() so the field shows up in \`forge sample:newTask --help\`.
+  // example: myParam: Schema.string().describe('What this parameter is for')
 })
 
 const boundaries = {

package/src/utils/taskAnalysis.ts

@@ -9,14 +9,22 @@ interface TaskLocation {
 interface SchemaProperty {
   name?: string
   type: string
+  format?: string
+  description?: string
+  // Internal marker used while building the schema; stripped in favour of the
+  // object-level `required` array (JSON Schema semantics) before output.
   optional?: boolean
   default?: string
   properties?: Record<string, SchemaProperty>
+  additionalProperties?: SchemaProperty | { anyOf: SchemaProperty[] }
 }
 
+// JSON Schema (draft 2020-12) representation of the task input, matching what
+// `Schema.describe()` produces at runtime.
 interface InputSchema {
   type: string
   properties: Record<string, SchemaProperty>
+  required?: string[]
 }
 
 interface OutputType {
@@ -558,69 +566,110 @@ function analyzeSchemaArg(node: ts.Expression, sourceFile: ts.SourceFile): Input
     const arg = node.arguments?.[0]
     if (arg && ts.isObjectLiteralExpression(arg)) {
       const properties: Record<string, SchemaProperty> = {}
+      const required: string[] = []
       arg.properties.forEach(prop => {
         if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
           const propName = prop.name.text
           const propValue = analyzeSchemaProp(prop.initializer, sourceFile)
+          // Optionality is expressed by absence from `required` (JSON Schema)
+          const isOptional = propValue.optional === true
+          delete propValue.optional
           properties[propName] = propValue
+          if (!isOptional) {
+            required.push(propName)
+          }
         }
       })
-      return { type: 'object', properties }
+      const result: InputSchema = { type: 'object', properties }
+      if (required.length > 0) {
+        result.required = required
+      }
+      return result
     }
   }
   return { type: 'object', properties: {} }
 }
 
-// Enhanced schema property analysis
-function analyzeSchemaProp(node: ts.Expression, sourceFile: ts.SourceFile): SchemaProperty {
-  // Analyze Schema.string(), Schema.number(), etc.
-  if (ts.isCallExpression(node)) {
-    if (ts.isPropertyAccessExpression(node.expression) &&
-      ts.isIdentifier(node.expression.expression) &&
-      node.expression.expression.text === 'Schema') {
-
-      const methodName = node.expression.name.text
-      const baseType: SchemaProperty = { type: getSchemaTypeFromMethod(methodName) }
-
-      return baseType
+// Analyze a single schema field, unwrapping the call chain
+// (e.g. Schema.string().describe('...').optional()) into a JSON Schema property.
+function analyzeSchemaProp(node: ts.Expression, _sourceFile: ts.SourceFile): SchemaProperty {
+  let optional = false
+  let description: string | undefined
+  let defaultValue: string | undefined
+
+  let current: ts.Expression = node
+  while (ts.isCallExpression(current) && ts.isPropertyAccessExpression(current.expression)) {
+    const methodName = current.expression.name.text
+    const inner = current.expression.expression
+
+    // Base call: Schema.<type>(...)
+    if (ts.isIdentifier(inner) && inner.text === 'Schema') {
+      const prop = mapSchemaMethod(methodName)
+      if (description !== undefined) {
+        prop.description = description
+      }
+      if (defaultValue !== undefined) {
+        prop.default = defaultValue
+      }
+      if (optional) {
+        prop.optional = true
+      }
+      return prop
     }
-  }
 
-  // Handle chained calls like Schema.number().optional()
-  if (ts.isCallExpression(node)) {
-    if (ts.isPropertyAccessExpression(node.expression)) {
-      const chainedMethod = node.expression.name.text
-      if (chainedMethod === 'optional') {
-        // This is a .optional() call, get the base type
-        const baseCall = node.expression.expression
-        if (ts.isCallExpression(baseCall)) {
-          const baseType = analyzeSchemaProp(baseCall, sourceFile)
-          return { ...baseType, optional: true }
-        }
-      } else if (chainedMethod === 'default') {
-        // This is a .default() call, get the base type
-        const baseCall = node.expression.expression
-        if (ts.isCallExpression(baseCall)) {
-          const baseType = analyzeSchemaProp(baseCall, sourceFile)
-          const defaultValue = node.arguments[0]?.getText() || 'undefined'
-          return { ...baseType, default: defaultValue }
-        }
+    // Chained modifiers
+    if (methodName === 'optional') {
+      optional = true
+    } else if (methodName === 'describe') {
+      const arg = current.arguments[0]
+      if (arg && ts.isStringLiteral(arg)) {
+        description = arg.text
       }
+    } else if (methodName === 'default') {
+      defaultValue = current.arguments[0]?.getText() ?? 'undefined'
     }
+    // Other modifiers (min/max/regex/...) don't change the JSON Schema type, so
+    // we keep unwrapping until we reach the base Schema.<type>() call.
+
+    current = inner
   }
 
   return { type: 'unknown' }
 }
 
-function getSchemaTypeFromMethod(methodName: string): string {
-  const typeMap: Record<string, string> = {
-    string: 'string',
-    number: 'number',
-    boolean: 'boolean',
-    array: 'array',
-    object: 'object'
+// Map a Schema.* helper name to its JSON Schema representation, matching what
+// Schema.describe() emits at runtime.
+function mapSchemaMethod(methodName: string): SchemaProperty {
+  switch (methodName) {
+  case 'string':
+    return { type: 'string' }
+  case 'number':
+    return { type: 'number' }
+  case 'boolean':
+    return { type: 'boolean' }
+  case 'date':
+    return { type: 'string', format: 'date-time' }
+  case 'email':
+    return { type: 'string', format: 'email' }
+  case 'uuid':
+    return { type: 'string', format: 'uuid' }
+  case 'url':
+    return { type: 'string', format: 'uri' }
+  case 'array':
+    return { type: 'array' }
+  case 'object':
+    return { type: 'object' }
+  case 'stringRecord':
+    return { type: 'object', additionalProperties: { type: 'string' } }
+  case 'numberRecord':
+    return { type: 'object', additionalProperties: { type: 'number' } }
+  case 'booleanRecord':
+    return { type: 'object', additionalProperties: { type: 'boolean' } }
+  case 'mixedRecord':
+    return { type: 'object', additionalProperties: { anyOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }] } }
+  default:
+    return { type: 'unknown' }
   }
-  return typeMap[methodName] || 'unknown'
 }
 
 

package/logs/bundle:fingerprint.log

@@ -1 +0,0 @@
-{"input":{"filePath":"/Users/danielzavaladlvega/forgehive/forge-mono-repo/apps/sample-project/src/tasks/test/errors.ts"},"boundaries":{"getCwd":[],"loadConf":[],"readFile":[],"writeFile":[],"ensureFingerprintsFolder":[]},"metadata":{"environment":"cli"},"metrics":[],"type":"error","error":"Invalid input on: descriptorName: Required"}