@forgehive/forge-cli 0.2.4 → 0.2.6

package/dist/tasks/init.js

@@ -27,7 +27,7 @@ exports.init = (0, task_1.createTask)(schema, boundaries, async function (argv,
     const forgePath = path_1.default.join(cwd, 'forge.json');
     const config = {
         project: {
-            name: 'ChangeMePls'
+            name: 'BaseProject'
         },
         paths: {
             logs: 'logs/',

package/dist/tasks/task/publish.js

@@ -101,6 +101,7 @@ exports.publish = (0, task_1.createTask)(schema, boundaries, async function ({ d
     const task = bundle[taskDescriptor.handler];
     const description = task.getDescription() ?? '';
     const schema = task.getSchema() || new schema_1.Schema({});
+    const boundaries = Object.keys(task.getBoundaries()) || [];
     const schemaDescriptor = schema.describe();
     // Read the task file content
     const sourceCode = await readFileUtf8(entryPoint);
@@ -114,6 +115,7 @@ exports.publish = (0, task_1.createTask)(schema, boundaries, async function ({ d
         projectName,
         description,
         schemaDescriptor: JSON.stringify(schemaDescriptor),
+        boundaries,
         sourceCode,
         bundleSize
     };

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

@@ -1,9 +1,10 @@
-import { type ForgeConf } from '../types';
+import { type ForgeConf, type Profile } from '../types';
 export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     descriptorName: string;
     args: Record<string, string | number | boolean>;
 }, boundaries: import("@forgehive/task").WrappedBoundaries<{
     loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;
@@ -15,8 +16,10 @@ export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     }) => Promise<Promise<any>>;
     verifyLogFolder: (logsPath: string) => Promise<boolean>;
     ensureBuildsFolder: () => Promise<string>;
+    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: unknown) => Promise<boolean>;
 }>) => Promise<any>, {
     loadConf: (args: {}) => Promise<Promise<ForgeConf>>;
+    loadCurrentProfile: (args: {}) => Promise<Promise<Profile>>;
     bundleCreate: (args: {
         entryPoint: string;
         outputFile: string;
@@ -28,4 +31,5 @@ export declare const run: import("@forgehive/task").TaskInstanceType<(argv: {
     }) => Promise<Promise<any>>;
     verifyLogFolder: (logsPath: string) => Promise<boolean>;
     ensureBuildsFolder: () => Promise<string>;
+    sendLogToAPI: (profile: Profile, projectName: string, taskName: string, logItem: unknown) => Promise<boolean>;
 }>;

package/dist/tasks/task/run.js

@@ -10,12 +10,14 @@ exports.run = void 0;
 const path_1 = __importDefault(require("path"));
 const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
+const axios_1 = __importDefault(require("axios"));
 const task_1 = require("@forgehive/task");
 const schema_1 = require("@forgehive/schema");
 const record_tape_1 = require("@forgehive/record-tape");
 const create_1 = require("../bundle/create");
 const load_1 = require("../bundle/load");
 const load_2 = require("../conf/load");
+const loadCurrent_1 = require("../auth/loadCurrent");
 // 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_1.Schema({
@@ -25,6 +27,7 @@ const schema = new schema_1.Schema({
 });
 const boundaries = {
     loadConf: load_2.load.asBoundary(),
+    loadCurrentProfile: loadCurrent_1.loadCurrent.asBoundary(),
     bundleCreate: create_1.create.asBoundary(),
     bundleLoad: load_1.load.asBoundary(),
     verifyLogFolder: async (logsPath) => {
@@ -46,15 +49,49 @@ const boundaries = {
             await promises_1.default.mkdir(buildsPath, { recursive: true });
         }
         return buildsPath;
+    },
+    sendLogToAPI: async (profile, projectName, taskName, logItem) => {
+        try {
+            const logsUrl = `${profile.url}/api/tasks/log-ingest`;
+            const authToken = `${profile.apiKey}:${profile.apiSecret}`;
+            await axios_1.default.post(logsUrl, {
+                projectName,
+                taskName,
+                logItem: JSON.stringify(logItem)
+            }, {
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            console.log('===============================================');
+            console.log('Log sent to API... ', profile.name, profile.url);
+            return true;
+        }
+        catch (e) {
+            const error = e;
+            console.error('Failed to send log to API:', error.message);
+            return false;
+        }
     }
 };
-exports.run = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName, args }, { loadConf, bundleCreate, bundleLoad, verifyLogFolder, ensureBuildsFolder }) {
+exports.run = (0, task_1.createTask)(schema, boundaries, async function ({ descriptorName, args }, { loadConf, bundleCreate, bundleLoad, verifyLogFolder, ensureBuildsFolder, loadCurrentProfile, sendLogToAPI }) {
     // Load forge configuration
     const forge = await loadConf({});
     const taskDescriptor = forge.tasks[descriptorName];
+    const projectName = forge.project.name;
     if (taskDescriptor === undefined) {
         throw new Error('Task is not defined on forge.json');
     }
+    // Try to load profile, but continue if not found
+    let profile = null;
+    try {
+        profile = await loadCurrentProfile({});
+    }
+    catch (error) {
+        // Profile not found or not configured, continue without it
+        console.log('No profile found, logs will not be sent to remote API');
+    }
     // Verify if log folder exists
     const logFolderPath = path_1.default.join(process.cwd(), forge.paths.logs);
     const logFolderExists = await verifyLogFolder(logFolderPath);
@@ -105,14 +142,26 @@ exports.run = (0, task_1.createTask)(schema, boundaries, async function ({ descr
     }
     tape.recordFrom(descriptorName, task);
     // Run the task with provided arguments
-    let result;
+    let result, error;
     try {
         result = await task.run(args);
     }
-    catch (error) {
-        await tape.save();
-        throw error;
+    catch (e) {
+        error = e;
     }
     await tape.save();
+    const logItems = tape.getLog();
+    const lastLogItem = logItems[logItems.length - 1];
+    if (profile) {
+        try {
+            await sendLogToAPI(profile, projectName, descriptorName, lastLogItem);
+        }
+        catch (e) {
+            console.error('Failed to send log to API:', e);
+        }
+    }
+    if (error) {
+        throw error;
+    }
     return result;
 });

package/dist/test/tasks/create.test.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const createTask_1 = require("../../tasks/task/createTask");
 const memfs_1 = require("memfs");
 const path_1 = __importDefault(require("path"));
-const utils_1 = require("../utils");
+const testUtils_1 = require("../testUtils");
 // Verify the task file content
 const expectedContent = `// TASK: newTask
 // Run this task with:
@@ -58,32 +58,31 @@ describe('Create task', () => {
     });
     afterEach(() => {
         jest.clearAllMocks();
+        // Reset any boundary mocks
+        createTask_1.createTaskCommand.resetMocks();
     });
     it('should create a new task file with correct content and update forge.json', async () => {
-        // Create properly typed mocks for the boundaries
-        const persistTaskMock = (0, utils_1.createBoundaryMock)();
-        const persistConfMock = (0, utils_1.createBoundaryMock)();
-        const getCwdMock = (0, utils_1.createBoundaryMock)();
-        const persistTaskFn = persistTaskMock;
-        const persistConfFn = persistConfMock;
-        const getCwdFn = getCwdMock;
-        // Override the persistTask implementation to use our in-memory fs
-        persistTaskFn.mockImplementation(async (dir, fileName, content, cwd) => {
+        // Create mock functions with Jest
+        const persistTaskFn = jest.fn().mockImplementation(async (dir, fileName, content, cwd) => {
             const fullPath = path_1.default.join(cwd, dir, fileName);
             await fs.promises.writeFile(fullPath, content);
             return { path: fullPath };
         });
-        // Override the persistConf implementation to use our in-memory fs
-        persistConfFn.mockImplementation(async (conf, cwd) => {
+        // Mock persistConf to use our in-memory fs
+        const persistConfFn = jest.fn().mockImplementation(async (conf, cwd) => {
             const forgePath = path_1.default.join(cwd, 'forge.json');
             await fs.promises.writeFile(forgePath, JSON.stringify(conf, null, 2));
         });
-        // Override the getCwd implementation to return our root directory
-        getCwdFn.mockResolvedValue(rootDir);
-        // Override the boundaries
-        createTask_1.createTaskCommand.getBoundaries().persistTask = persistTaskMock;
-        createTask_1.createTaskCommand.getBoundaries().persistConf = persistConfMock;
-        createTask_1.createTaskCommand.getBoundaries().getCwd = getCwdMock;
+        // Mock getCwd to return our root directory
+        const getCwdFn = jest.fn().mockResolvedValue(rootDir);
+        // Create boundary mocks with proper type casting
+        const persistTaskMock = (0, testUtils_1.createMockBoundary)(persistTaskFn);
+        const persistConfMock = (0, testUtils_1.createMockBoundary)(persistConfFn);
+        const getCwdMock = (0, testUtils_1.createMockBoundary)(getCwdFn);
+        // Use the mockBoundary method to mock the boundaries
+        createTask_1.createTaskCommand.mockBoundary('persistTask', persistTaskMock);
+        createTask_1.createTaskCommand.mockBoundary('persistConf', persistConfMock);
+        createTask_1.createTaskCommand.mockBoundary('getCwd', getCwdMock);
         // Run the task
         const taskName = 'sample:new-task';
         await createTask_1.createTaskCommand.run({ descriptorName: taskName });

package/dist/test/tasks/init.test.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const init_1 = require("../../tasks/init");
 const memfs_1 = require("memfs");
 const path_1 = __importDefault(require("path"));
-const utils_1 = require("../utils");
+const testUtils_1 = require("../testUtils");
 describe('Init task', () => {
     let volume;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -20,30 +20,29 @@ describe('Init task', () => {
     });
     afterEach(() => {
         jest.clearAllMocks();
+        // Reset any boundary mocks after each test
+        init_1.init.resetMocks();
     });
     it('should create forge.json with correct content in the filesystem', async () => {
-        // Create properly typed mocks for the boundaries
-        const saveFileMock = (0, utils_1.createBoundaryMock)();
-        const getCwdMock = (0, utils_1.createBoundaryMock)();
-        const saveFileFn = saveFileMock;
-        const getCwdFn = getCwdMock;
-        // Override the saveFile implementation to use our in-memory fs
-        saveFileFn.mockImplementation(async (filePath, content) => {
+        // Create mocks directly using Jest
+        const saveFileFn = jest.fn().mockImplementation(async (filePath, content) => {
             const fullPath = path_1.default.join(rootDir, filePath);
             await fs.promises.writeFile(fullPath, content);
         });
-        // Override the getCwd implementation to return our root directory
-        getCwdFn.mockResolvedValue(rootDir);
-        // Override the boundaries
-        init_1.init.getBoundaries().saveFile = saveFileMock;
-        init_1.init.getBoundaries().getCwd = getCwdMock;
+        const getCwdFn = jest.fn().mockResolvedValue(rootDir);
+        // Create wrapped boundary mocks
+        const saveFileMock = (0, testUtils_1.createMockBoundary)(saveFileFn);
+        const getCwdMock = (0, testUtils_1.createMockBoundary)(getCwdFn);
+        // Mock the boundaries
+        init_1.init.mockBoundary('saveFile', saveFileMock);
+        init_1.init.mockBoundary('getCwd', getCwdMock);
         // Run the task
         await init_1.init.run({});
         // Read the created file
         const fileContent = await fs.promises.readFile(path_1.default.join(rootDir, 'forge.json'), 'utf-8');
         const config = JSON.parse(fileContent);
         // Verify the file content
-        expect(config).toHaveProperty('project.name', 'ChangeMePls');
+        expect(config).toHaveProperty('project.name', 'BaseProject');
         expect(config).toHaveProperty('paths.logs', 'logs/');
         expect(config).toHaveProperty('paths.tasks', 'src/tasks/');
         expect(config).toHaveProperty('infra.region', 'us-west-2');
@@ -51,22 +50,21 @@ describe('Init task', () => {
         expect(config).toHaveProperty('runners');
     });
     it('should not create forge.json when dryRun is true', async () => {
-        // Create properly typed mocks for the boundaries
-        const saveFileMock = (0, utils_1.createBoundaryMock)();
-        const getCwdMock = (0, utils_1.createBoundaryMock)();
-        const saveFileFn = saveFileMock;
-        const getCwdFn = getCwdMock;
-        // Override the getCwd implementation to return our root directory
-        getCwdFn.mockResolvedValue(rootDir);
-        // Override the boundaries
-        init_1.init.getBoundaries().saveFile = saveFileMock;
-        init_1.init.getBoundaries().getCwd = getCwdMock;
+        // Create mocks directly using Jest
+        const saveFileFn = jest.fn();
+        const getCwdFn = jest.fn().mockResolvedValue(rootDir);
+        // Create wrapped boundary mocks
+        const saveFileMock = (0, testUtils_1.createMockBoundary)(saveFileFn);
+        const getCwdMock = (0, testUtils_1.createMockBoundary)(getCwdFn);
+        // Mock the boundaries
+        init_1.init.mockBoundary('saveFile', saveFileMock);
+        init_1.init.mockBoundary('getCwd', getCwdMock);
         // Run the task with dryRun flag
         const result = await init_1.init.run({ dryRun: true });
         // Verify saveFile was not called
         expect(saveFileFn).not.toHaveBeenCalled();
         // Verify the returned config has the correct structure
-        expect(result).toHaveProperty('project.name', 'ChangeMePls');
+        expect(result).toHaveProperty('project.name', 'BaseProject');
         expect(result).toHaveProperty('paths.logs', 'logs/');
         expect(result).toHaveProperty('paths.tasks', 'src/tasks/');
         expect(result).toHaveProperty('infra.region', 'us-west-2');

package/dist/test/testUtils.d.ts

@@ -0,0 +1,8 @@
+import { type WrappedBoundaryFunction } from '@forgehive/task';
+/**
+ * Creates a mock boundary function that implements the WrappedBoundaryFunction interface
+ *
+ * @param mockFn Optional Jest mock function to use as the base function
+ * @returns A wrapped boundary function compatible with task.mockBoundary()
+ */
+export declare const createMockBoundary: (mockFn?: jest.Mock) => WrappedBoundaryFunction;

package/dist/test/testUtils.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMockBoundary = void 0;
+/**
+ * Creates a mock boundary function that implements the WrappedBoundaryFunction interface
+ *
+ * @param mockFn Optional Jest mock function to use as the base function
+ * @returns A wrapped boundary function compatible with task.mockBoundary()
+ */
+const createMockBoundary = (mockFn) => {
+    // Use provided mock or create a new one
+    const baseMockFn = mockFn || jest.fn().mockResolvedValue(undefined);
+    // Create a proper boundary function object that extends the mock function
+    const boundaryMock = Object.assign(baseMockFn, {
+        getTape: jest.fn().mockReturnValue([]),
+        setTape: jest.fn(),
+        getMode: jest.fn().mockReturnValue('proxy'),
+        setMode: jest.fn(),
+        startRun: jest.fn(),
+        stopRun: jest.fn(),
+        getRunData: jest.fn().mockReturnValue([])
+    });
+    return boundaryMock;
+};
+exports.createMockBoundary = createMockBoundary;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -13,7 +13,7 @@
       "@forgehive/record-tape": "^0.0.1",
       "@forgehive/runner": "^0.1.4",
       "@forgehive/schema": "^0.1.4",
-      "@forgehive/task": "^0.1.5",
+      "@forgehive/task": "^0.1.6",
       "esbuild": "^0.25.0",
       "handlebars": "^4.7.8",
       "minimist": "^1.2.8"
@@ -25,10 +25,10 @@
     "esbuild": "^0.25.0",
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
-    "@forgehive/task": "0.1.5",
-    "@forgehive/record-tape": "0.0.2",
-    "@forgehive/runner": "0.1.5",
-    "@forgehive/schema": "0.1.4"
+    "@forgehive/record-tape": "0.0.3",
+    "@forgehive/runner": "0.1.6",
+    "@forgehive/schema": "0.1.4",
+    "@forgehive/task": "0.1.6"
   },
   "devDependencies": {
     "@types/jest": "^29.5.3",

package/src/tasks/init.ts

@@ -32,7 +32,7 @@ export const init = createTask(
 
     const config: ForgeConf = {
       project: {
-        name: 'ChangeMePls'
+        name: 'BaseProject'
       },
       paths: {
         logs: 'logs/',

package/src/tasks/task/publish.ts

@@ -126,6 +126,7 @@ export const publish = createTask(
     const task = bundle[taskDescriptor.handler]
     const description = task.getDescription() ?? ''
     const schema = task.getSchema() || new Schema({})
+    const boundaries = Object.keys(task.getBoundaries()) || []
     const schemaDescriptor = schema.describe()
 
     // Read the task file content
@@ -142,6 +143,7 @@ export const publish = createTask(
       projectName,
       description,
       schemaDescriptor: JSON.stringify(schemaDescriptor),
+      boundaries,
       sourceCode,
       bundleSize
     }

package/src/tasks/task/run.ts

@@ -5,6 +5,7 @@
 import path from 'path'
 import fs from 'fs/promises'
 import os from 'os'
+import axios from 'axios'
 
 import { createTask } from '@forgehive/task'
 import { Schema } from '@forgehive/schema'
@@ -13,7 +14,8 @@ import { RecordTape } from '@forgehive/record-tape'
 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'
+import { loadCurrent as loadCurrentProfile } from '../auth/loadCurrent'
+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
@@ -25,6 +27,7 @@ const schema = new Schema({
 
 const boundaries = {
   loadConf: loadConf.asBoundary(),
+  loadCurrentProfile: loadCurrentProfile.asBoundary(),
   bundleCreate: bundleCreate.asBoundary(),
   bundleLoad: bundleLoad.asBoundary(),
   verifyLogFolder: async (logsPath: string): Promise<boolean> => {
@@ -46,21 +49,65 @@ const boundaries = {
     }
 
     return buildsPath
+  },
+  sendLogToAPI: async (profile: Profile, projectName: string, taskName: string, logItem: unknown): Promise<boolean> => {
+    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)
+      }, {
+        headers: {
+          Authorization: `Bearer ${authToken}`,
+          'Content-Type': 'application/json'
+        }
+      })
+
+      console.log('===============================================')
+      console.log('Log sent to API... ', profile.name, profile.url)
+
+      return true
+    } catch (e) {
+      const error = e as Error
+      console.error('Failed to send log to API:', error.message)
+      return false
+    }
   }
 }
 
 export const run = createTask(
   schema,
   boundaries,
-  async function ({ descriptorName, args }, { loadConf, bundleCreate, bundleLoad, verifyLogFolder, ensureBuildsFolder }) {
+  async function ({ descriptorName, args }, {
+    loadConf,
+    bundleCreate,
+    bundleLoad,
+    verifyLogFolder,
+    ensureBuildsFolder,
+    loadCurrentProfile,
+    sendLogToAPI
+  }) {
     // 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 is not defined on forge.json')
     }
 
+    // Try to load profile, but continue if not found
+    let profile = null
+    try {
+      profile = await loadCurrentProfile({})
+    } catch (error) {
+      // Profile not found or not configured, continue without it
+      console.log('No profile found, logs will not be sent to remote API')
+    }
+
     // Verify if log folder exists
     const logFolderPath = path.join(process.cwd(), forge.paths.logs)
     const logFolderExists = await verifyLogFolder(logFolderPath)
@@ -122,15 +169,28 @@ export const run = createTask(
     tape.recordFrom(descriptorName, task)
 
     // Run the task with provided arguments
-    let result
+    let result, error
     try {
       result = await task.run(args)
-    } catch (error) {
-      await tape.save()
-      throw error
+    } catch (e) {
+      error = e as Error
     }
 
     await tape.save()
+    const logItems = tape.getLog()
+    const lastLogItem = logItems[logItems.length - 1]
+
+    if (profile) {
+      try {
+        await sendLogToAPI(profile, projectName, descriptorName, lastLogItem)
+      } catch (e) {
+        console.error('Failed to send log to API:', e)
+      }
+    }
+
+    if (error) {
+      throw error
+    }
 
     return result
   }

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

@@ -1,7 +1,7 @@
 import { createTaskCommand } from '../../tasks/task/createTask'
 import { createFsFromVolume, Volume } from 'memfs'
 import path from 'path'
-import { createBoundaryMock } from '../utils'
+import { createMockBoundary } from '../testUtils'
 import { ForgeConf } from '../../tasks/types'
 
 // Verify the task file content
@@ -59,37 +59,36 @@ describe('Create task', () => {
 
   afterEach(() => {
     jest.clearAllMocks()
+    // Reset any boundary mocks
+    createTaskCommand.resetMocks()
   })
 
   it('should create a new task file with correct content and update forge.json', async () => {
-    // Create properly typed mocks for the boundaries
-    const persistTaskMock = createBoundaryMock()
-    const persistConfMock = createBoundaryMock()
-    const getCwdMock = createBoundaryMock()
-    const persistTaskFn = persistTaskMock as unknown as jest.Mock
-    const persistConfFn = persistConfMock as unknown as jest.Mock
-    const getCwdFn = getCwdMock as unknown as jest.Mock
-
-    // Override the persistTask implementation to use our in-memory fs
-    persistTaskFn.mockImplementation(async (dir: string, fileName: string, content: string, cwd: string) => {
+    // Create mock functions with Jest
+    const persistTaskFn = jest.fn().mockImplementation(async (dir: string, fileName: string, content: string, cwd: string) => {
       const fullPath = path.join(cwd, dir, fileName)
       await (fs as { promises: { writeFile: (path: string, content: string) => Promise<void> } }).promises.writeFile(fullPath, content)
       return { path: fullPath }
     })
 
-    // Override the persistConf implementation to use our in-memory fs
-    persistConfFn.mockImplementation(async (conf: ForgeConf, cwd: string) => {
+    // Mock persistConf to use our in-memory fs
+    const persistConfFn = jest.fn().mockImplementation(async (conf: ForgeConf, cwd: string) => {
       const forgePath = path.join(cwd, 'forge.json')
       await (fs as { promises: { writeFile: (path: string, content: string) => Promise<void> } }).promises.writeFile(forgePath, JSON.stringify(conf, null, 2))
     })
 
-    // Override the getCwd implementation to return our root directory
-    getCwdFn.mockResolvedValue(rootDir)
+    // Mock getCwd to return our root directory
+    const getCwdFn = jest.fn().mockResolvedValue(rootDir)
 
-    // Override the boundaries
-    createTaskCommand.getBoundaries().persistTask = persistTaskMock
-    createTaskCommand.getBoundaries().persistConf = persistConfMock
-    createTaskCommand.getBoundaries().getCwd = getCwdMock
+    // Create boundary mocks with proper type casting
+    const persistTaskMock = createMockBoundary(persistTaskFn)
+    const persistConfMock = createMockBoundary(persistConfFn)
+    const getCwdMock = createMockBoundary(getCwdFn)
+
+    // Use the mockBoundary method to mock the boundaries
+    createTaskCommand.mockBoundary('persistTask', persistTaskMock)
+    createTaskCommand.mockBoundary('persistConf', persistConfMock)
+    createTaskCommand.mockBoundary('getCwd', getCwdMock)
 
     // Run the task
     const taskName = 'sample:new-task'

package/src/test/tasks/init.test.ts

@@ -1,7 +1,7 @@
 import { init } from '../../tasks/init'
 import { createFsFromVolume, Volume } from 'memfs'
 import path from 'path'
-import { createBoundaryMock } from '../utils'
+import { createMockBoundary } from '../testUtils'
 
 describe('Init task', () => {
   let volume: InstanceType<typeof Volume>
@@ -18,27 +18,26 @@ describe('Init task', () => {
 
   afterEach(() => {
     jest.clearAllMocks()
+    // Reset any boundary mocks after each test
+    init.resetMocks()
   })
 
   it('should create forge.json with correct content in the filesystem', async () => {
-    // Create properly typed mocks for the boundaries
-    const saveFileMock = createBoundaryMock()
-    const getCwdMock = createBoundaryMock()
-    const saveFileFn = saveFileMock as unknown as jest.Mock
-    const getCwdFn = getCwdMock as unknown as jest.Mock
-
-    // Override the saveFile implementation to use our in-memory fs
-    saveFileFn.mockImplementation(async (filePath: string, content: string) => {
+    // Create mocks directly using Jest
+    const saveFileFn = jest.fn().mockImplementation(async (filePath: string, content: string) => {
       const fullPath = path.join(rootDir, filePath)
       await (fs as { promises: { writeFile: (path: string, content: string) => Promise<void> } }).promises.writeFile(fullPath, content)
     })
 
-    // Override the getCwd implementation to return our root directory
-    getCwdFn.mockResolvedValue(rootDir)
+    const getCwdFn = jest.fn().mockResolvedValue(rootDir)
 
-    // Override the boundaries
-    init.getBoundaries().saveFile = saveFileMock
-    init.getBoundaries().getCwd = getCwdMock
+    // Create wrapped boundary mocks
+    const saveFileMock = createMockBoundary(saveFileFn)
+    const getCwdMock = createMockBoundary(getCwdFn)
+
+    // Mock the boundaries
+    init.mockBoundary('saveFile', saveFileMock)
+    init.mockBoundary('getCwd', getCwdMock)
 
     // Run the task
     await init.run({})
@@ -48,7 +47,7 @@ describe('Init task', () => {
     const config = JSON.parse(fileContent)
 
     // Verify the file content
-    expect(config).toHaveProperty('project.name', 'ChangeMePls')
+    expect(config).toHaveProperty('project.name', 'BaseProject')
     expect(config).toHaveProperty('paths.logs', 'logs/')
     expect(config).toHaveProperty('paths.tasks', 'src/tasks/')
     expect(config).toHaveProperty('infra.region', 'us-west-2')
@@ -57,18 +56,17 @@ describe('Init task', () => {
   })
 
   it('should not create forge.json when dryRun is true', async () => {
-    // Create properly typed mocks for the boundaries
-    const saveFileMock = createBoundaryMock()
-    const getCwdMock = createBoundaryMock()
-    const saveFileFn = saveFileMock as unknown as jest.Mock
-    const getCwdFn = getCwdMock as unknown as jest.Mock
+    // Create mocks directly using Jest
+    const saveFileFn = jest.fn()
+    const getCwdFn = jest.fn().mockResolvedValue(rootDir)
 
-    // Override the getCwd implementation to return our root directory
-    getCwdFn.mockResolvedValue(rootDir)
+    // Create wrapped boundary mocks
+    const saveFileMock = createMockBoundary(saveFileFn)
+    const getCwdMock = createMockBoundary(getCwdFn)
 
-    // Override the boundaries
-    init.getBoundaries().saveFile = saveFileMock
-    init.getBoundaries().getCwd = getCwdMock
+    // Mock the boundaries
+    init.mockBoundary('saveFile', saveFileMock)
+    init.mockBoundary('getCwd', getCwdMock)
 
     // Run the task with dryRun flag
     const result = await init.run({ dryRun: true })
@@ -77,7 +75,7 @@ describe('Init task', () => {
     expect(saveFileFn).not.toHaveBeenCalled()
 
     // Verify the returned config has the correct structure
-    expect(result).toHaveProperty('project.name', 'ChangeMePls')
+    expect(result).toHaveProperty('project.name', 'BaseProject')
     expect(result).toHaveProperty('paths.logs', 'logs/')
     expect(result).toHaveProperty('paths.tasks', 'src/tasks/')
     expect(result).toHaveProperty('infra.region', 'us-west-2')

package/src/test/testUtils.ts

@@ -0,0 +1,28 @@
+import { type WrappedBoundaryFunction } from '@forgehive/task'
+
+/**
+ * Creates a mock boundary function that implements the WrappedBoundaryFunction interface
+ *
+ * @param mockFn Optional Jest mock function to use as the base function
+ * @returns A wrapped boundary function compatible with task.mockBoundary()
+ */
+export const createMockBoundary = (mockFn?: jest.Mock): WrappedBoundaryFunction => {
+  // Use provided mock or create a new one
+  const baseMockFn = mockFn || jest.fn().mockResolvedValue(undefined)
+
+  // Create a proper boundary function object that extends the mock function
+  const boundaryMock = Object.assign(
+    baseMockFn,
+    {
+      getTape: jest.fn().mockReturnValue([]),
+      setTape: jest.fn(),
+      getMode: jest.fn().mockReturnValue('proxy'),
+      setMode: jest.fn(),
+      startRun: jest.fn(),
+      stopRun: jest.fn(),
+      getRunData: jest.fn().mockReturnValue([])
+    }
+  ) as WrappedBoundaryFunction
+
+  return boundaryMock
+}

package/src/test/utils.ts

@@ -1,17 +0,0 @@
-import { type WrappedBoundaryFunction } from '@forgehive/task'
-
-export const createBoundaryMock = (): WrappedBoundaryFunction => {
-  const mockFn = jest.fn().mockResolvedValue(undefined)
-  const boundaryMock = mockFn as unknown as WrappedBoundaryFunction
-
-  // Add required methods to satisfy the interface
-  boundaryMock.getTape = jest.fn().mockReturnValue([])
-  boundaryMock.setTape = jest.fn()
-  boundaryMock.getMode = jest.fn().mockReturnValue('proxy')
-  boundaryMock.setMode = jest.fn()
-  boundaryMock.startRun = jest.fn()
-  boundaryMock.stopRun = jest.fn()
-  boundaryMock.getRunData = jest.fn().mockReturnValue([])
-
-  return boundaryMock
-}