@forgehive/forge-cli 0.3.13 → 0.3.15

package/dist/runner.js

@@ -163,9 +163,10 @@ runner.setHandler(async (data) => {
             });
         }
         else if (taskName === 'docs:download') {
-            const { path } = args;
+            const { path, logs } = args;
             result = await task.run({
-                path
+                path,
+                logs
             });
         }
         else if (taskName === 'project:create') {

package/dist/tasks/docs/download.d.ts

@@ -1,5 +1,6 @@
 export declare const download: import("@forgehive/task").TaskInstanceType<(argv: {
     path?: string | undefined;
+    logs?: boolean | undefined;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     fetchFile: (url: string) => Promise<string>;
     getCurrentWorkingDirectory: () => Promise<string>;
@@ -8,9 +9,13 @@ export declare const download: import("@forgehive/task").TaskInstanceType<(argv:
     checkFileExists: (filePath: string) => Promise<boolean>;
 }>) => Promise<{
     success: boolean;
-    filePath: string;
-    targetPath: string;
-    size: number;
+    downloads: {
+        type: string;
+        filePath: string;
+        targetPath: string;
+        size: number;
+    }[];
+    totalFiles: number;
 }>, {
     fetchFile: (url: string) => Promise<string>;
     getCurrentWorkingDirectory: () => Promise<string>;

package/dist/tasks/docs/download.js

@@ -3,6 +3,8 @@
 // Run this task with:
 // forge task:run docs:download
 // forge task:run docs:download --path="custom/path/forge.md"
+// forge task:run docs:download --logs
+// forge task:run docs:download --logs --path="custom/path/forge.md"
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -45,10 +47,12 @@ const task_1 = require("@forgehive/task");
 const schema_1 = require("@forgehive/schema");
 const path_1 = __importDefault(require("path"));
 const name = 'docs:download';
-const description = 'Download the ForgeHive LLM guide from GitHub to local project';
+const description = 'Download ForgeHive LLM guides from GitHub to local project';
 const LLM_GUIDE_URL = 'https://raw.githubusercontent.com/forge-and-hive/forge-mono-repo/refs/heads/main/docs/llm.md';
+const LLM_HIVE_LOGGING_URL = 'https://raw.githubusercontent.com/forge-and-hive/forge-mono-repo/refs/heads/main/docs/llm-hive-logging.md';
 const schema = new schema_1.Schema({
-    path: schema_1.Schema.string().optional()
+    path: schema_1.Schema.string().optional(),
+    logs: schema_1.Schema.boolean().optional()
 });
 const boundaries = {
     fetchFile: async (url) => {
@@ -85,30 +89,63 @@ exports.download = (0, task_1.createTask)({
     description,
     schema,
     boundaries,
-    fn: async function ({ path: customPath }, { fetchFile, getCurrentWorkingDirectory, createDirectory, writeFile, checkFileExists }) {
-        // Determine the target path
-        const targetPath = customPath || 'docs/forge.md';
+    fn: async function ({ path: customPath, logs }, { fetchFile, getCurrentWorkingDirectory, createDirectory, writeFile, checkFileExists }) {
         const cwd = await getCurrentWorkingDirectory();
-        const fullPath = path_1.default.resolve(cwd, targetPath);
-        const dirPath = path_1.default.dirname(fullPath);
-        console.log(`Downloading ForgeHive LLM guide to: ${targetPath}`);
+        const results = [];
+        // Download main LLM guide
+        const mainTargetPath = customPath || 'docs/forge.md';
+        const mainFullPath = path_1.default.resolve(cwd, mainTargetPath);
+        const mainDirPath = path_1.default.dirname(mainFullPath);
+        console.log(`Downloading ForgeHive LLM guide to: ${mainTargetPath}`);
         // Check if file already exists
-        const fileExists = await checkFileExists(fullPath);
-        if (fileExists) {
-            console.log(`Warning: File already exists at ${targetPath}. It will be overwritten.`);
+        const mainFileExists = await checkFileExists(mainFullPath);
+        if (mainFileExists) {
+            console.log(`Warning: File already exists at ${mainTargetPath}. It will be overwritten.`);
         }
-        // Download the file content
-        const content = await fetchFile(LLM_GUIDE_URL);
+        // Download the main guide content
+        const mainContent = await fetchFile(LLM_GUIDE_URL);
         // Create directory if it doesn't exist
-        await createDirectory(dirPath);
-        // Write the file
-        await writeFile(fullPath, content);
-        console.log(`✅ Successfully downloaded ForgeHive LLM guide to ${targetPath}`);
+        await createDirectory(mainDirPath);
+        // Write the main guide file
+        await writeFile(mainFullPath, mainContent);
+        console.log(`✅ Successfully downloaded ForgeHive LLM guide to ${mainTargetPath}`);
+        results.push({
+            type: 'main',
+            filePath: mainFullPath,
+            targetPath: mainTargetPath,
+            size: mainContent.length
+        });
+        // Download Hive logging guide if --logs flag is provided
+        if (logs) {
+            const logsTargetPath = customPath
+                ? path_1.default.join(path_1.default.dirname(customPath), 'hive-logging.md')
+                : 'docs/hive-logging.md';
+            const logsFullPath = path_1.default.resolve(cwd, logsTargetPath);
+            const logsDirPath = path_1.default.dirname(logsFullPath);
+            console.log(`Downloading Hive Logging guide to: ${logsTargetPath}`);
+            // Check if logs file already exists
+            const logsFileExists = await checkFileExists(logsFullPath);
+            if (logsFileExists) {
+                console.log(`Warning: File already exists at ${logsTargetPath}. It will be overwritten.`);
+            }
+            // Download the logs guide content
+            const logsContent = await fetchFile(LLM_HIVE_LOGGING_URL);
+            // Create directory if it doesn't exist
+            await createDirectory(logsDirPath);
+            // Write the logs guide file
+            await writeFile(logsFullPath, logsContent);
+            console.log(`✅ Successfully downloaded Hive Logging guide to ${logsTargetPath}`);
+            results.push({
+                type: 'logs',
+                filePath: logsFullPath,
+                targetPath: logsTargetPath,
+                size: logsContent.length
+            });
+        }
         return {
             success: true,
-            filePath: fullPath,
-            targetPath,
-            size: content.length
+            downloads: results,
+            totalFiles: results.length
         };
     }
 });

package/dist/tasks/task/invoke.d.ts

@@ -7,10 +7,10 @@ export declare const invoke: import("@forgehive/task").TaskInstanceType<(argv: {
     loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
     loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
     parseJSON: (jsonString: string) => Promise<unknown>;
-    invokeTask: (projectUuid: string, profile: Profile, taskName: string, payload: unknown) => Promise<InvokeResult | null>;
+    invokeTask: (projectUuid: string, taskUuid: string, profile: Profile, taskName: string, payload: unknown) => Promise<InvokeResult | null>;
 }>) => Promise<unknown>, {
     loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
     loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
     parseJSON: (jsonString: string) => Promise<unknown>;
-    invokeTask: (projectUuid: string, profile: Profile, taskName: string, payload: unknown) => Promise<InvokeResult | null>;
+    invokeTask: (projectUuid: string, taskUuid: string, profile: Profile, taskName: string, payload: unknown) => Promise<InvokeResult | null>;
 }>;

package/dist/tasks/task/invoke.js

@@ -26,17 +26,17 @@ const boundaries = {
             throw new Error(`Invalid JSON: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     },
-    invokeTask: async (projectUuid, profile, taskName, payload) => {
+    invokeTask: async (projectUuid, taskUuid, profile, taskName, payload) => {
         const client = (0, hive_sdk_1.createHiveClient)({
             projectUuid,
             apiKey: profile.apiKey,
             apiSecret: profile.apiSecret,
             host: profile.url
         });
-        console.log(`Invoking task: ${taskName}`);
+        console.log(`Invoking task: ${taskName} (${taskUuid})`);
         console.log('Payload:', payload);
         console.log(`Using profile: ${profile.name} (${profile.url})`);
-        return await client.invoke(taskName, payload);
+        return await client.invoke(taskUuid, payload);
     }
 };
 exports.invoke = (0, task_1.createTask)({
@@ -51,10 +51,13 @@ exports.invoke = (0, task_1.createTask)({
         if (taskDescriptor === undefined) {
             throw new Error(`Task "${descriptorName}" is not defined in forge.json`);
         }
-        // Check for project UUID
+        // Check for required UUIDs
         if (!forge.project.uuid) {
             throw new Error('Project UUID is not defined in forge.json. Please ensure your project has a UUID.');
         }
+        if (!taskDescriptor.uuid) {
+            throw new Error(`Task "${descriptorName}" does not have a UUID in forge.json. Please ensure your task has a UUID.`);
+        }
         // Load profile (required for invoke)
         let profile;
         try {
@@ -66,7 +69,7 @@ exports.invoke = (0, task_1.createTask)({
         // Parse the JSON payload
         const payload = await parseJSON(json);
         // Invoke the task using the boundary
-        const result = await invokeTask(forge.project.uuid, profile, descriptorName, payload);
+        const result = await invokeTask(forge.project.uuid, taskDescriptor.uuid, profile, descriptorName, payload);
         if ((0, hive_sdk_1.isInvokeError)(result)) {
             throw new Error(`Task invocation failed: ${result.error}`);
         }

package/dist/tasks/task/publish.d.ts

@@ -47,7 +47,7 @@ export declare const publish: import("@forgehive/task").TaskInstanceType<(argv:
     }>>;
     readFileUtf8: (filePath: string) => Promise<string>;
     readFileBinary: (filePath: string) => Promise<Buffer>;
-    publishTask: (data: Record<string, unknown>, profile: Profile) => Promise<{
+    publishTask: (projectUuid: string, taskUuid: string, data: Record<string, unknown>, profile: Profile) => Promise<{
         bundleUploadUrl?: string;
     }>;
     uploadBundleWithPresignedUrl: (presignedUrl: string, bundleContent: Buffer) => Promise<boolean>;
@@ -101,7 +101,7 @@ export declare const publish: import("@forgehive/task").TaskInstanceType<(argv:
     }>>;
     readFileUtf8: (filePath: string) => Promise<string>;
     readFileBinary: (filePath: string) => Promise<Buffer>;
-    publishTask: (data: Record<string, unknown>, profile: Profile) => Promise<{
+    publishTask: (projectUuid: string, taskUuid: string, data: Record<string, unknown>, profile: Profile) => Promise<{
         bundleUploadUrl?: string;
     }>;
     uploadBundleWithPresignedUrl: (presignedUrl: string, bundleContent: Buffer) => Promise<boolean>;

package/dist/tasks/task/publish.js

@@ -38,8 +38,8 @@ const boundaries = {
     readFileBinary: async (filePath) => {
         return promises_1.default.readFile(filePath);
     },
-    publishTask: async (data, profile) => {
-        const publishUrl = `${profile.url}/api/tasks/publish`;
+    publishTask: async (projectUuid, taskUuid, data, profile) => {
+        const publishUrl = `${profile.url}/api/projects/${projectUuid}/tasks/${taskUuid}/publish`;
         const authToken = `${profile.apiKey}:${profile.apiSecret}`;
         try {
             const response = await axios_1.default.post(publishUrl, data, {
@@ -91,6 +91,13 @@ exports.publish = (0, task_1.createTask)({
         if (taskDescriptor === undefined) {
             throw new Error('Task is not defined on forge.json');
         }
+        // Check for required UUIDs
+        if (!forgeJson.project.uuid) {
+            throw new Error('Project UUID is not defined in forge.json. Please ensure your project has a UUID.');
+        }
+        if (!taskDescriptor.uuid) {
+            throw new Error(`Task "${descriptorName}" does not have a UUID in forge.json. Please ensure your task has a UUID.`);
+        }
         const entryPoint = path_1.default.join(cwd, taskDescriptor.path);
         const buildsPath = await ensureBuildsFolder();
         const outputFile = path_1.default.join(buildsPath, `${descriptorName}.js`);
@@ -158,7 +165,7 @@ exports.publish = (0, task_1.createTask)({
         };
         // Publish metadata to hive api server
         console.log(`Publishing metadata and source code to ${profile.url}...`);
-        const publishResponse = await publishTask(data, profile);
+        const publishResponse = await publishTask(forgeJson.project.uuid, taskDescriptor.uuid, data, profile);
         // Upload zipped bundle using the presigned URL
         if (publishResponse.bundleUploadUrl) {
             console.log('Uploading zipped bundle...');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,7 +10,7 @@
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/hive-sdk": "^0.1.4",
+      "@forgehive/hive-sdk": "^0.1.5",
       "@forgehive/record-tape": "^0.2.6",
       "@forgehive/runner": "^0.2.6",
       "@forgehive/schema": "^0.1.4",
@@ -30,11 +30,11 @@
     "minimist": "^1.2.8",
     "typescript": "^5.3.3",
     "uuid": "^11.1.0",
-    "@forgehive/record-tape": "0.2.6",
-    "@forgehive/hive-sdk": "0.1.4",
+    "@forgehive/schema": "0.1.4",
     "@forgehive/task": "0.2.6",
-    "@forgehive/runner": "0.2.6",
-    "@forgehive/schema": "0.1.4"
+    "@forgehive/hive-sdk": "0.1.5",
+    "@forgehive/record-tape": "0.2.6",
+    "@forgehive/runner": "0.2.6"
   },
   "devDependencies": {
     "@types/archiver": "^6.0.3",

package/src/runner.ts

@@ -184,10 +184,11 @@ runner.setHandler(async (data: ParsedArgs): Promise<unknown> => {
         profileName: String(action)
       })
     } else if (taskName === 'docs:download') {
-      const { path } = args as { path?: string }
+      const { path, logs } = args as { path?: string, logs?: boolean }
 
       result = await task.run({
-        path
+        path,
+        logs
       })
     } else if (taskName === 'project:create') {
       const { projectName, description } = args as { projectName?: string, description?: string }

package/src/tasks/docs/download.ts

@@ -2,18 +2,22 @@
 // Run this task with:
 // forge task:run docs:download
 // forge task:run docs:download --path="custom/path/forge.md"
+// forge task:run docs:download --logs
+// forge task:run docs:download --logs --path="custom/path/forge.md"
 
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
 import path from 'path'
 
 const name = 'docs:download'
-const description = 'Download the ForgeHive LLM guide from GitHub to local project'
+const description = 'Download ForgeHive LLM guides from GitHub to local project'
 
 const LLM_GUIDE_URL = 'https://raw.githubusercontent.com/forge-and-hive/forge-mono-repo/refs/heads/main/docs/llm.md'
+const LLM_HIVE_LOGGING_URL = 'https://raw.githubusercontent.com/forge-and-hive/forge-mono-repo/refs/heads/main/docs/llm-hive-logging.md'
 
 const schema = new Schema({
-  path: Schema.string().optional()
+  path: Schema.string().optional(),
+  logs: Schema.boolean().optional()
 })
 
 const boundaries = {
@@ -51,37 +55,80 @@ export const download = createTask({
   description,
   schema,
   boundaries,
-  fn: async function ({ path: customPath }, { fetchFile, getCurrentWorkingDirectory, createDirectory, writeFile, checkFileExists }) {
-    // Determine the target path
-    const targetPath = customPath || 'docs/forge.md'
+  fn: async function ({ path: customPath, logs }, { fetchFile, getCurrentWorkingDirectory, createDirectory, writeFile, checkFileExists }) {
     const cwd = await getCurrentWorkingDirectory()
-    const fullPath = path.resolve(cwd, targetPath)
-    const dirPath = path.dirname(fullPath)
+    const results = []
 
-    console.log(`Downloading ForgeHive LLM guide to: ${targetPath}`)
+    // Download main LLM guide
+    const mainTargetPath = customPath || 'docs/forge.md'
+    const mainFullPath = path.resolve(cwd, mainTargetPath)
+    const mainDirPath = path.dirname(mainFullPath)
+
+    console.log(`Downloading ForgeHive LLM guide to: ${mainTargetPath}`)
 
     // Check if file already exists
-    const fileExists = await checkFileExists(fullPath)
-    if (fileExists) {
-      console.log(`Warning: File already exists at ${targetPath}. It will be overwritten.`)
+    const mainFileExists = await checkFileExists(mainFullPath)
+    if (mainFileExists) {
+      console.log(`Warning: File already exists at ${mainTargetPath}. It will be overwritten.`)
     }
 
-    // Download the file content
-    const content = await fetchFile(LLM_GUIDE_URL)
+    // Download the main guide content
+    const mainContent = await fetchFile(LLM_GUIDE_URL)
 
     // Create directory if it doesn't exist
-    await createDirectory(dirPath)
+    await createDirectory(mainDirPath)
+
+    // Write the main guide file
+    await writeFile(mainFullPath, mainContent)
+
+    console.log(`✅ Successfully downloaded ForgeHive LLM guide to ${mainTargetPath}`)
+
+    results.push({
+      type: 'main',
+      filePath: mainFullPath,
+      targetPath: mainTargetPath,
+      size: mainContent.length
+    })
+
+    // Download Hive logging guide if --logs flag is provided
+    if (logs) {
+      const logsTargetPath = customPath
+        ? path.join(path.dirname(customPath), 'hive-logging.md')
+        : 'docs/hive-logging.md'
+      const logsFullPath = path.resolve(cwd, logsTargetPath)
+      const logsDirPath = path.dirname(logsFullPath)
+
+      console.log(`Downloading Hive Logging guide to: ${logsTargetPath}`)
 
-    // Write the file
-    await writeFile(fullPath, content)
+      // Check if logs file already exists
+      const logsFileExists = await checkFileExists(logsFullPath)
+      if (logsFileExists) {
+        console.log(`Warning: File already exists at ${logsTargetPath}. It will be overwritten.`)
+      }
 
-    console.log(`✅ Successfully downloaded ForgeHive LLM guide to ${targetPath}`)
+      // Download the logs guide content
+      const logsContent = await fetchFile(LLM_HIVE_LOGGING_URL)
+
+      // Create directory if it doesn't exist
+      await createDirectory(logsDirPath)
+
+      // Write the logs guide file
+      await writeFile(logsFullPath, logsContent)
+
+      console.log(`✅ Successfully downloaded Hive Logging guide to ${logsTargetPath}`)
+
+      results.push({
+        type: 'logs',
+        filePath: logsFullPath,
+        targetPath: logsTargetPath,
+        size: logsContent.length
+      })
+    }
 
     return {
       success: true,
-      filePath: fullPath,
-      targetPath,
-      size: content.length
+      downloads: results,
+      totalFiles: results.length
     }
   }
 })

package/src/tasks/task/invoke.ts

@@ -30,6 +30,7 @@ const boundaries = {
   },
   invokeTask: async (
     projectUuid: string,
+    taskUuid: string,
     profile: Profile,
     taskName: string,
     payload: unknown
@@ -41,11 +42,11 @@ const boundaries = {
       host: profile.url
     })
 
-    console.log(`Invoking task: ${taskName}`)
+    console.log(`Invoking task: ${taskName} (${taskUuid})`)
     console.log('Payload:', payload)
     console.log(`Using profile: ${profile.name} (${profile.url})`)
 
-    return await client.invoke(taskName, payload)
+    return await client.invoke(taskUuid, payload)
   }
 }
 
@@ -63,11 +64,15 @@ export const invoke = createTask({
       throw new Error(`Task "${descriptorName}" is not defined in forge.json`)
     }
 
-    // Check for project UUID
+    // Check for required UUIDs
     if (!forge.project.uuid) {
       throw new Error('Project UUID is not defined in forge.json. Please ensure your project has a UUID.')
     }
 
+    if (!taskDescriptor.uuid) {
+      throw new Error(`Task "${descriptorName}" does not have a UUID in forge.json. Please ensure your task has a UUID.`)
+    }
+
     // Load profile (required for invoke)
     let profile: Profile
     try {
@@ -80,7 +85,7 @@ export const invoke = createTask({
     const payload = await parseJSON(json)
 
     // Invoke the task using the boundary
-    const result = await invokeTask(forge.project.uuid, profile, descriptorName, payload)
+    const result = await invokeTask(forge.project.uuid, taskDescriptor.uuid, profile, descriptorName, payload)
 
     if (isInvokeError(result)) {
       throw new Error(`Task invocation failed: ${result.error}`)

package/src/tasks/task/publish.ts

@@ -39,8 +39,13 @@ const boundaries = {
   readFileBinary: async (filePath: string): Promise<Buffer> => {
     return fs.readFile(filePath)
   },
-  publishTask: async (data: Record<string, unknown>, profile: Profile): Promise<{ bundleUploadUrl?: string }> => {
-    const publishUrl = `${profile.url}/api/tasks/publish`
+  publishTask: async (
+    projectUuid: string,
+    taskUuid: string,
+    data: Record<string, unknown>,
+    profile: Profile
+  ): Promise<{ bundleUploadUrl?: string }> => {
+    const publishUrl = `${profile.url}/api/projects/${projectUuid}/tasks/${taskUuid}/publish`
     const authToken = `${profile.apiKey}:${profile.apiSecret}`
 
     try {
@@ -112,6 +117,15 @@ export const publish = createTask({
       throw new Error('Task is not defined on forge.json')
     }
 
+    // Check for required UUIDs
+    if (!forgeJson.project.uuid) {
+      throw new Error('Project UUID is not defined in forge.json. Please ensure your project has a UUID.')
+    }
+
+    if (!taskDescriptor.uuid) {
+      throw new Error(`Task "${descriptorName}" does not have a UUID in forge.json. Please ensure your task has a UUID.`)
+    }
+
     const entryPoint = path.join(cwd, taskDescriptor.path)
     const buildsPath = await ensureBuildsFolder()
     const outputFile = path.join(buildsPath, `${descriptorName}.js`)
@@ -190,7 +204,7 @@ export const publish = createTask({
 
     // Publish metadata to hive api server
     console.log(`Publishing metadata and source code to ${profile.url}...`)
-    const publishResponse = await publishTask(data, profile)
+    const publishResponse = await publishTask(forgeJson.project.uuid, taskDescriptor.uuid, data, profile)
 
     // Upload zipped bundle using the presigned URL
     if (publishResponse.bundleUploadUrl) {