@forgehive/forge-cli 0.2.7 → 0.2.9

package/dist/taskAdapter.d.ts

@@ -0,0 +1,34 @@
+import { TaskInstanceType, BaseFunction, Boundaries, ExecutionRecord, ReplayConfig } from '@forgehive/task';
+import { SchemaDescription } from '@forgehive/schema';
+/**
+ * TaskAdapter wraps a TaskInstanceType to make it compatible with Runner
+ * by handling boundary type issues
+ */
+export declare class TaskAdapter<F extends BaseFunction, B extends Boundaries> {
+    private task;
+    constructor(task: TaskInstanceType<F, B>);
+    get version(): string;
+    getDescription(): string | undefined;
+    describe(): SchemaDescription;
+    run(argv?: Parameters<F>[0]): Promise<ReturnType<F>>;
+    safeReplay(executionLog: ExecutionRecord<any, any, any>, config: ReplayConfig<any>): Promise<[ReturnType<F> | null, Error | null, ExecutionRecord<Parameters<F>[0], ReturnType<F>, B>]>;
+    getMode(): import("@forgehive/task").Mode;
+    setMode(mode: string): void;
+    validate(argv?: any): any;
+    isValid(argv?: any): boolean;
+    addListener(fn: any): void;
+    removeListener(): void;
+    emit(data: any): void;
+    asBoundary(): (args: Parameters<F>[0]) => Promise<ReturnType<F>>;
+    getBoundaries(): import("@forgehive/task").WrappedBoundaries<B>;
+    setBoundariesData(data: any): void;
+    getBondariesData(): Record<string, unknown>;
+    mockBoundary(name: any, mockFn: any): any;
+    resetMock(name: any): any;
+    resetMocks(): void;
+    safeRun(argv?: Parameters<F>[0]): Promise<[ReturnType<F> | null, Error | null, ExecutionRecord<Parameters<F>[0], ReturnType<F>, B>]>;
+}
+/**
+ * Helper function to adapt a task instance for Runner compatibility
+ */
+export declare function adaptTask<F extends BaseFunction, B extends Boundaries>(task: TaskInstanceType<F, B>): TaskInstanceType;

package/dist/taskAdapter.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskAdapter = void 0;
+exports.adaptTask = adaptTask;
+/**
+ * TaskAdapter wraps a TaskInstanceType to make it compatible with Runner
+ * by handling boundary type issues
+ */
+class TaskAdapter {
+    constructor(task) {
+        this.task = task;
+    }
+    // Forward all required methods to the underlying task
+    get version() {
+        return this.task.version;
+    }
+    getDescription() {
+        return this.task.getDescription();
+    }
+    describe() {
+        return this.task.describe();
+    }
+    async run(argv) {
+        return this.task.run(argv);
+    }
+    // This is the problematic method with boundary type incompatibilities
+    // Our implementation uses type assertions to make it compatible
+    async safeReplay(executionLog, config) {
+        // Type assertion to bridge the boundary type gap
+        return this.task.safeReplay(executionLog, config);
+    }
+    // Forward other methods as needed
+    getMode() {
+        return this.task.getMode();
+    }
+    setMode(mode) {
+        return this.task.setMode(mode);
+    }
+    validate(argv) {
+        return this.task.validate(argv);
+    }
+    isValid(argv) {
+        return this.task.isValid(argv);
+    }
+    addListener(fn) {
+        return this.task.addListener(fn);
+    }
+    removeListener() {
+        return this.task.removeListener();
+    }
+    emit(data) {
+        return this.task.emit(data);
+    }
+    asBoundary() {
+        return this.task.asBoundary();
+    }
+    getBoundaries() {
+        return this.task.getBoundaries();
+    }
+    setBoundariesData(data) {
+        return this.task.setBoundariesData(data);
+    }
+    getBondariesData() {
+        return this.task.getBondariesData();
+    }
+    mockBoundary(name, mockFn) {
+        return this.task.mockBoundary(name, mockFn);
+    }
+    resetMock(name) {
+        return this.task.resetMock(name);
+    }
+    resetMocks() {
+        return this.task.resetMocks();
+    }
+    async safeRun(argv) {
+        return this.task.safeRun(argv);
+    }
+}
+exports.TaskAdapter = TaskAdapter;
+/**
+ * Helper function to adapt a task instance for Runner compatibility
+ */
+function adaptTask(task) {
+    return new TaskAdapter(task);
+}

package/dist/tasks/task/run.js

@@ -140,21 +140,15 @@ exports.run = (0, task_1.createTask)(schema, boundaries, async function ({ descr
     catch (_error) {
         // if the tape is not found, create a new one on saving
     }
-    tape.recordFrom(descriptorName, task);
     // Run the task with provided arguments
-    let result, error;
-    try {
-        result = await task.run(args);
-    }
-    catch (e) {
-        error = e;
-    }
+    const [result, error, record] = await task.safeRun(args);
+    const logItem = tape.push(descriptorName, record, {
+        environment: 'cli'
+    });
     await tape.save();
-    const logItems = tape.getLog();
-    const lastLogItem = logItems[logItems.length - 1];
     if (profile) {
         try {
-            await sendLogToAPI(profile, projectName, descriptorName, lastLogItem);
+            await sendLogToAPI(profile, projectName, descriptorName, logItem);
         }
         catch (e) {
             console.error('Failed to send log to API:', e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/forge-cli",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "TypeScript CLI application",
   "license": "MIT",
   "main": "dist/index.js",
@@ -10,7 +10,7 @@
   "publishConfig": {
     "access": "public",
     "dependencies": {
-      "@forgehive/record-tape": "^0.1.0",
+      "@forgehive/record-tape": "^0.1.1",
       "@forgehive/runner": "^0.1.7",
       "@forgehive/schema": "^0.1.4",
       "@forgehive/task": "^0.1.7",
@@ -25,10 +25,10 @@
     "esbuild": "^0.25.0",
     "handlebars": "^4.7.8",
     "minimist": "^1.2.8",
+    "@forgehive/runner": "0.1.8",
+    "@forgehive/record-tape": "0.1.2",
     "@forgehive/schema": "0.1.4",
-    "@forgehive/record-tape": "0.1.0",
-    "@forgehive/runner": "0.1.7",
-    "@forgehive/task": "0.1.7"
+    "@forgehive/task": "0.1.8"
   },
   "devDependencies": {
     "@types/jest": "^29.5.3",

package/src/tasks/task/run.ts

@@ -166,23 +166,16 @@ export const run = createTask(
       // if the tape is not found, create a new one on saving
     }
 
-    tape.recordFrom(descriptorName, task)
-
     // Run the task with provided arguments
-    let result, error
-    try {
-      result = await task.run(args)
-    } catch (e) {
-      error = e as Error
-    }
-
+    const [result, error, record] = await task.safeRun(args)
+    const logItem = tape.push(descriptorName, record, {
+      environment: 'cli'
+    })
     await tape.save()
-    const logItems = tape.getLog()
-    const lastLogItem = logItems[logItems.length - 1]
 
     if (profile) {
       try {
-        await sendLogToAPI(profile, projectName, descriptorName, lastLogItem)
+        await sendLogToAPI(profile, projectName, descriptorName, logItem)
       } catch (e) {
         console.error('Failed to send log to API:', e)
       }