testbeats 2.2.8 → 2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testbeats",
-  "version": "2.2.8",
+  "version": "2.3.1",
   "description": "Publish test results to Microsoft Teams, Google Chat, Slack and InfluxDB",
   "main": "src/index.js",
   "types": "./src/index.d.ts",
@@ -50,13 +50,14 @@
     "dotenv": "^16.4.5",
     "form-data-lite": "^1.0.3",
     "influxdb-lite": "^1.0.0",
+    "object-hash": "^3.0.0",
     "performance-results-parser": "latest",
     "phin-retry": "^1.0.3",
     "pretty-ms": "^7.0.1",
     "prompts": "^2.4.2",
     "rosters": "0.0.1",
     "sade": "^1.8.1",
-    "test-results-parser": "0.2.8"
+    "test-results-parser": "0.2.9"
   },
   "devDependencies": {
     "c8": "^10.1.2",

package/src/beats/beats.api.js

@@ -9,6 +9,15 @@ class BeatsApi {
     this.config = config;
   }
 
+  searchProjects(search_text) {
+    return request.get({
+      url: `${this.getBaseUrl()}/api/core/v1/projects?search_text=${search_text}`,
+      headers: {
+        'x-api-key': this.config.api_key
+      }
+    });
+  }
+
   postTestRun(payload) {
     return request.post({
       url: `${this.getBaseUrl()}/api/core/v1/test-runs`,
@@ -75,6 +84,40 @@ class BeatsApi {
       }
     });
   }
+
+  /**
+   * @param {import('../types').IManualSyncComparePayload} payload
+   * @returns {Promise<import('../types').IManualSyncCompareResponse>}
+   */
+  compareManualTests(payload) {
+    return request.post({
+      url: `${this.getBaseUrl()}/api/core/v1/manual/sync/compare`,
+      headers: {
+        'x-api-key': this.config.api_key
+      },
+      body: payload
+    });
+  }
+
+  syncManualFolders(payload) {
+    return request.post({
+      url: `${this.getBaseUrl()}/api/core/v1/manual/sync/folders`,
+      headers: {
+        'x-api-key': this.config.api_key
+      },
+      body: payload
+    });
+  }
+
+  syncManualTestSuites(payload) {
+    return request.post({
+      url: `${this.getBaseUrl()}/api/core/v1/manual/sync/suites`,
+      headers: {
+        'x-api-key': this.config.api_key
+      },
+      body: payload
+    });
+  }
 }
 
 module.exports = { BeatsApi }

package/src/cli.js

@@ -6,6 +6,7 @@ const sade = require('sade');
 const prog = sade('testbeats');
 const { PublishCommand } = require('./commands/publish.command');
 const { GenerateConfigCommand } = require('./commands/generate-config.command');
+const { ManualSyncCommand } = require('./commands/manual-sync.command');
 const logger = require('./utils/logger');
 const pkg = require('../package.json');
 
@@ -63,4 +64,24 @@ prog.command('init')
     }
   });
 
+// Command to sync manual test cases from gherkin files
+prog.command('manual sync')
+  .describe('Sync manual test cases from gherkin files in a directory')
+  .option('-p, --path', 'Path to directory to sync (default: current directory)')
+  .option('-c, --config', 'path to config file')
+  .option('--api-key', 'api key')
+  .option('--project', 'project name')
+  .example('manual sync')
+  .example('manual sync --path ./tests/features')
+  .action(async (opts) => {
+    try {
+      logger.setLevel(opts.logLevel);
+      const manual_sync_command = new ManualSyncCommand(opts);
+      await manual_sync_command.execute();
+    } catch (error) {
+      logger.error(`Manual sync failed: ${error.message}`);
+      process.exit(1);
+    }
+  });
+
 prog.parse(process.argv);

package/src/commands/base.command.js

@@ -0,0 +1,47 @@
+const pkg = require('../../package.json');
+const { MIN_NODE_VERSION } = require('../helpers/constants');
+const { ConfigBuilder } = require('../utils/config.builder');
+const logger = require('../utils/logger');
+const os = require('os');
+
+class BaseCommand {
+  constructor(opts) {
+    this.opts = opts;
+  }
+
+  printBanner() {
+    const banner = `
+     _____             _    ___                  _
+    (_   _)           ( )_ (  _'\\               ( )_
+      | |   __    ___ | ,_)| (_) )   __     _ _ | ,_)  ___
+      | | /'__'\\/',__)| |  |  _ <' /'__'\\ /'_' )| |  /',__)
+      | |(  ___/\\__, \\| |_ | (_) )(  ___/( (_| || |_ \\__, \\
+      (_)'\\____)(____/'\\__)(____/''\\____)'\\__,_)'\\__)(____/
+
+                         v${pkg.version}
+    `;
+    console.log(banner);
+  }
+
+  validateEnvDetails() {
+    try {
+      const current_major_version = parseInt(process.version.split('.')[0].replace('v', ''));
+      if (current_major_version >= MIN_NODE_VERSION) {
+        logger.info(`💻 NodeJS: ${process.version}, OS: ${os.platform()}, Version: ${os.release()}, Arch: ${os.machine()}`);
+        return;
+      }
+    } catch (error) {
+      logger.warn(`⚠️ Unable to verify NodeJS version: ${error.message}`);
+      return;
+    }
+    throw new Error(`❌ Supported NodeJS version is >= v${MIN_NODE_VERSION}. Current version is ${process.version}`)
+  }
+
+  buildConfig() {
+    const config_builder = new ConfigBuilder(this.opts);
+    config_builder.build();
+  }
+
+}
+
+module.exports = { BaseCommand };

package/src/commands/manual-sync.command.js

@@ -0,0 +1,311 @@
+const { ManualSyncHelper } = require('../manual/sync.helper');
+const logger = require('../utils/logger');
+const { BeatsApi } = require('../beats/beats.api');
+const { BaseCommand } = require('./base.command');
+
+class ManualSyncCommand extends BaseCommand {
+  /**
+   * @param {Object} opts - Command options
+   */
+  constructor(opts) {
+    super(opts);
+    this.syncHelper = new ManualSyncHelper();
+  }
+
+  /**
+   * Execute the manual sync command
+   */
+  async execute() {
+    try {
+      this.printBanner();
+      this.validateEnvDetails();
+      this.buildConfig();
+
+      logger.info('🔄 Starting manual test case sync...');
+
+      const targetPath = this.opts.path || '.';
+      logger.info(`📁 Scanning directory: ${targetPath}`);
+
+      const result = await this.syncHelper.scanDirectory(targetPath);
+
+      const counts = this.getCounts(result);
+      logger.info(`📊 Found ${counts.totalTestCases} test cases, ${counts.totalTestSuites} test suites, and ${counts.totalFolders} folders`);
+
+      // Format output as specified in requirements
+      const output = {
+        folders: result.folders
+      };
+
+
+
+      const beats = new BeatsApi(this.opts.config);
+      const projectsResponse = await beats.searchProjects(this.opts.config.project);
+      const project = projectsResponse.values.find(p => p.name === this.opts.config.project);
+      if (!project) {
+        throw new Error(`Project ${this.opts.config.project} not found`);
+      }
+      this.opts.config.project = project.id;
+
+      const compare = new ManualSyncCompare(this.opts.config);
+      const compareResult = await compare.compare(output);
+
+      const resources = new ManualSyncResources(this.opts.config);
+      await resources.sync(output, compareResult);
+
+    } catch (error) {
+      logger.error(`❌ Manual sync failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  getCounts(result, counts = { totalTestCases: 0, totalTestSuites: 0, totalFolders: 0 }) {
+    // return the total number of test cases, test suites, and folders
+    for (const folder of result.folders) {
+      counts.totalTestCases += folder.test_suites.reduce((acc, suite) => acc + suite.test_cases.length, 0);
+      counts.totalTestSuites += folder.test_suites.length;
+      counts.totalFolders += folder.folders.length;
+      this.getCounts(folder, counts);
+    }
+    return counts;
+  }
+}
+
+class ManualSyncCompare {
+
+  constructor(config) {
+    this.config = config;
+    this.beats = new BeatsApi(this.config);
+  }
+
+  /**
+   * @param {import('../types').IManualTestFolder} structure
+   */
+  async compare(structure) {
+    const payload = this.#buildPayload(structure);
+    const response = await this.beats.compareManualTests(payload);
+    return response;
+  }
+
+
+  /**
+   * Build the payload for the compare manual tests API
+   * @param {import('../types').IManualTestFolder} structure
+   * @returns {import('../types').IManualSyncComparePayload}
+   */
+  #buildPayload(structure) {
+    const payload = {
+      project_id: this.config.project,
+      folders: [],
+    };
+    for (const folder of structure.folders) {
+      payload.folders.push(this.#buildPayloadFolder(folder));
+    }
+    return payload;
+  }
+
+  /**
+   * Build the payload for a folder
+   * @param {import('../types').IManualTestFolder} folder
+   * @returns {import('../types').IManualSyncCompareFolder}
+   */
+  #buildPayloadFolder(folder) {
+    return {
+      name: folder.name,
+      hash: folder.hash,
+      test_suites: folder.test_suites.map(testSuite => this.#buildPayloadTestSuite(testSuite)),
+      folders: folder.folders.map(subFolder => this.#buildPayloadFolder(subFolder))
+    };
+  }
+
+  /**
+   * Build the payload for a test suite
+   * @param {import('../types').IManualTestSuite} testSuite
+   * @returns {import('../types').IManualSyncCompareTestSuite}
+   */
+  #buildPayloadTestSuite(testSuite) {
+    return {
+      name: testSuite.name,
+      hash: testSuite.hash,
+    };
+  }
+}
+
+class ManualSyncResources {
+  constructor(config) {
+    this.config = config;
+    this.beats = new BeatsApi(this.config);
+  }
+
+  /**
+   * Sync the manual resources
+   * @param {import('../types').IManualTestFolder} structure
+   * @param {import('../types').IManualSyncCompareResponse} compareResult
+   */
+  async sync(structure, compareResult) {
+    this.#mergeStructure(structure, compareResult);
+    await this.#syncFolders(structure.folders);
+  }
+
+  /**
+   * Merge the structure with the compare result
+   * @param {import('../types').IManualTestFolder} structure
+   * @param {import('../types').IManualSyncCompareResponse} compareResult
+   */
+  #mergeStructure(structure, compareResult) {
+    // Iterate through all folders from compare result and merge with local structure
+    for (const serverFolder of compareResult.folders) {
+      const localFolder = structure.folders.find(f => f.name === serverFolder.name);
+      if (localFolder) {
+        this.#mergeFolder(localFolder, serverFolder);
+      } else {
+        structure.folders.push(this.#convertServerFolderToLocal(serverFolder));
+      }
+    }
+  }
+
+  /**
+   * Merge server folder metadata into local folder
+   * @param {import('../types').IManualTestFolder} localFolder - Local folder with full data
+   * @param {import('../types').IManualSyncCompareResponseFolder} serverFolder - Server folder with metadata
+   */
+  #mergeFolder(localFolder, serverFolder) {
+    // Enrich local folder with server metadata
+    localFolder.id = serverFolder.id;
+    localFolder.type = serverFolder.type;
+
+    // Ensure server folder has test suites and folders
+    serverFolder.test_suites = serverFolder.test_suites || [];
+    serverFolder.folders = serverFolder.folders || [];
+
+    for (const serverSuite of serverFolder.test_suites) {
+      const localSuite = localFolder.test_suites.find(s => s.name === serverSuite.name);
+      if (localSuite) {
+        this.#mergeTestSuite(localSuite, serverSuite);
+      } else {
+        localFolder.test_suites.push(this.#convertServerSuiteToLocal(serverSuite));
+      }
+    }
+
+    for (const serverSubFolder of serverFolder.folders) {
+      const localSubFolder = localFolder.folders.find(f => f.name === serverSubFolder.name);
+      if (localSubFolder) {
+        this.#mergeFolder(localSubFolder, serverSubFolder);
+      } else {
+        localFolder.folders.push(this.#convertServerFolderToLocal(serverSubFolder));
+      }
+    }
+  }
+
+  /**
+   * Merge server test suite metadata into local test suite
+   * @param {import('../types').IManualTestSuite} localSuite - Local test suite with full data
+   * @param {import('../types').IManualSyncCompareResponseTestSuite} serverSuite - Server suite with metadata
+   */
+  #mergeTestSuite(localSuite, serverSuite) {
+    localSuite.id = serverSuite.id;
+    localSuite.type = serverSuite.type;
+  }
+
+  /**
+   * Convert server folder to local folder structure (for delete operations)
+   * @param {import('../types').IManualSyncCompareResponseFolder} serverFolder - Server folder
+   * @returns {import('../types').IManualTestFolder} Local folder structure
+   */
+  #convertServerFolderToLocal(serverFolder) {
+    return {
+      name: serverFolder.name,
+      path: '',
+      hash: serverFolder.hash,
+      id: serverFolder.id,
+      type: serverFolder.type,
+      test_suites: serverFolder.test_suites?.map(s => this.#convertServerSuiteToLocal(s)) || [],
+      folders: serverFolder.folders?.map(f => this.#convertServerFolderToLocal(f)) || []
+    };
+  }
+
+  /**
+   * Convert server test suite to local test suite structure (for delete operations)
+   * @param {import('../types').IManualSyncCompareResponseTestSuite} serverSuite - Server suite
+   * @returns {import('../types').IManualTestSuite} Local test suite structure
+   */
+  #convertServerSuiteToLocal(serverSuite) {
+    return {
+      name: serverSuite.name,
+      tags: [],
+      before_each: [],
+      test_cases: [],
+      hash: serverSuite.hash,
+      id: serverSuite.id,
+      type: serverSuite.type
+    };
+  }
+
+  async #syncFolders(folders) {
+    const payload = {
+      project_id: this.config.project,
+      folders: folders.map(folder => ({
+        type: folder.type,
+        id: folder.id,
+        name: folder.name,
+        hash: folder.hash,
+        parent_folder_id: folder.parent_folder_id,
+      })),
+    };
+    const response = await this.beats.syncManualFolders(payload);
+    const results = response.results;
+    for (const result of results) {
+      if (result.success) {
+        logger.info(`✅ Folder '${result.name}' synced successfully`);
+        const folder = folders.find(f => f.name === result.name);
+        if (!folder) {
+          console.log(`❌ Folder ${result.name} not found in local structure`);
+          continue;
+        }
+        folder.id = folder.id || result.id;
+        for (const testSuite of folder.test_suites) {
+          testSuite.folder_id = folder.id;
+        }
+        await this.#syncTestSuites(folder.test_suites);
+        for (const subFolder of folder.folders) {
+          subFolder.parent_folder_id = folder.id;
+        }
+        await this.#syncFolders(folder.folders);
+      }
+    }
+  }
+
+  async #syncTestSuites(testSuites) {
+    const payload = {
+      project_id: this.config.project,
+      suites: testSuites.map(testSuite => ({
+        type: testSuite.type,
+        name: testSuite.name,
+        folder_id: testSuite.folder_id,
+        hash: testSuite.hash,
+        tags: testSuite.tags,
+        before_each: testSuite.before_each.map(step => step.name),
+        test_cases: testSuite.test_cases.map(tc => {
+          return {
+            name: tc.name,
+            type: tc.type,
+            tags: tc.tags,
+            steps: tc.steps.map(step => step.name),
+            hash: tc.hash,
+          };
+        }),
+      })),
+    };
+    const response = await this.beats.syncManualTestSuites(payload);
+    const results = response.results;
+    for (const result of results) {
+      if (result.success) {
+        logger.info(`✅ Test Suite '${result.name}' synced successfully`);
+      } else {
+        logger.error(`❌ Test Suite '${result.name}' failed to sync: ${result.error}`);
+      }
+    }
+  }
+
+}
+
+module.exports = { ManualSyncCommand, ManualSyncCompare };

package/src/commands/publish.command.js

@@ -1,33 +1,29 @@
 const path = require('path');
 const trp = require('test-results-parser');
 const prp = require('performance-results-parser');
-const os = require('os');
 
 const beats = require('../beats');
-const { ConfigBuilder } = require('../utils/config.builder');
 const target_manager = require('../targets');
 const logger = require('../utils/logger');
 const { processData } = require('../helpers/helper');
 const { ExtensionsSetup } = require('../setups/extensions.setup');
-const pkg = require('../../package.json');
-const { MIN_NODE_VERSION } = require('../helpers/constants');
 const { sortExtensionsByOrder } = require('../helpers/extension.helper');
+const { BaseCommand } = require('./base.command');
 
-class PublishCommand {
+class PublishCommand extends BaseCommand {
 
   /**
    * @param {import('../index').CommandLineOptions} opts
    */
   constructor(opts) {
-    this.opts = opts;
+    super(opts);
     this.errors = [];
   }
 
   async publish() {
-    logger.info(`🥁 TestBeats v${pkg.version}`);
-
-    this.#validateEnvDetails();
-    this.#buildConfig();
+    this.printBanner();
+    this.validateEnvDetails();
+    this.buildConfig();
     this.#validateOptions();
     this.#setConfigFromFile();
     this.#mergeConfigOptions();
@@ -39,25 +35,6 @@ class PublishCommand {
     await this.#publishErrors();
   }
 
-  #validateEnvDetails() {
-    try {
-      const current_major_version = parseInt(process.version.split('.')[0].replace('v', ''));
-      if (current_major_version >= MIN_NODE_VERSION) {
-        logger.info(`💻 NodeJS: ${process.version}, OS: ${os.platform()}, Version: ${os.release()}, Arch: ${os.machine()}`);
-        return;
-      }
-    } catch (error) {
-      logger.warn(`⚠️ Unable to verify NodeJS version: ${error.message}`);
-      return;
-    }
-    throw new Error(`❌ Supported NodeJS version is >= v${MIN_NODE_VERSION}. Current version is ${process.version}`)
-  }
-
-  #buildConfig() {
-    const config_builder = new ConfigBuilder(this.opts);
-    config_builder.build();
-  }
-
   #validateOptions() {
     if (!this.opts) {
       throw new Error('Missing publish options');

package/src/helpers/constants.js

@@ -15,6 +15,7 @@ const TARGET = Object.freeze({
   TEAMS: 'teams',
   CHAT: 'chat',
   GITHUB: 'github',
+  GITHUB_OUTPUT: 'github-output',
   CUSTOM: 'custom',
   DELAY: 'delay',
   INFLUX: 'influx',

package/src/index.d.ts

@@ -10,7 +10,7 @@ export interface ITarget {
   name: TargetName;
   enable?: string | boolean;
   condition?: Condition;
-  inputs?: SlackInputs | TeamsInputs | ChatInputs | IGitHubInputs | ICustomTargetInputs | InfluxDBTargetInputs;
+  inputs?: SlackInputs | TeamsInputs | ChatInputs | IGitHubInputs | IGitHubOutputInputs | ICustomTargetInputs | InfluxDBTargetInputs;
   extensions?: IExtension[];
 }
 
@@ -25,7 +25,7 @@ export interface IExtension {
 
 export type ExtensionName = 'report-portal-analysis' | 'hyperlinks' | 'mentions' | 'report-portal-history' | 'quick-chart-test-summary' | 'metadata' | 'ci-info' | 'custom' | 'ai-failure-summary';
 export type Hook = 'start' | 'end' | 'after-summary';
-export type TargetName = 'slack' | 'teams' | 'chat' | 'github' | 'custom' | 'delay';
+export type TargetName = 'slack' | 'teams' | 'chat' | 'github' | 'github-output' | 'custom' | 'delay';
 export type PublishReportType = 'test-summary' | 'test-summary-slim' | 'failure-details';
 
 export interface ConditionFunctionContext {
@@ -251,6 +251,11 @@ export interface IGitHubInputs extends TargetInputs {
   pull_number?: string;
 }
 
+export interface IGitHubOutputInputs {
+  output_file?: string;
+  key?: string;
+}
+
 export interface InfluxDBTargetInputs {
   url: string;
   version?: string;

package/src/manual/parsers/base.js

@@ -0,0 +1,39 @@
+const hash = require('object-hash');
+
+class BaseParser {
+  hash(obj) {
+    return hash(obj, { algorithm: 'md5' });
+  }
+
+  /**
+   * Hash a test case
+   * @param {import('../../types').IManualTestCase} testCase
+   * @returns {string}
+   */
+  hashTestCase(testCase) {
+    return this.hash({
+      name: testCase.name,
+      type: testCase.type,
+      tags: testCase.tags,
+      steps: testCase.steps,
+      path: testCase.path
+    });
+  }
+
+  /**
+   * Hash a test suite
+   * @param {import('../../types').IManualTestSuite} testSuite
+   * @returns {string}
+   */
+  hashTestSuite(testSuite) {
+    return this.hash({
+      name: testSuite.name,
+      type: testSuite.type,
+      tags: testSuite.tags,
+      before_each: testSuite.before_each,
+      test_cases: testSuite.test_cases.map(testCase => testCase.hash)
+    });
+  }
+}
+
+module.exports = { BaseParser };

package/src/manual/parsers/gherkin.js

@@ -0,0 +1,247 @@
+const fs = require('fs');
+const { BaseParser } = require('./base');
+
+/**
+ * Simple and extendable Gherkin parser for Cucumber feature files
+ * Parses .feature files and returns structured test suite objects
+ */
+class GherkinParser extends BaseParser {
+  constructor() {
+    super();
+    /** @type {string[]} Supported step keywords */
+    this.stepKeywords = ['Given', 'When', 'Then', 'And', 'But'];
+  }
+
+  /**
+   * @param {string} file_path
+   * @returns {Object} Parsed test suite structure
+   */
+  parse(file_path) {
+    try {
+      const content = fs.readFileSync(file_path, 'utf8');
+      const lines = content.split('\n').map(line => line.trim()).filter(line => line.length > 0);
+
+      return this.parseLines(lines);
+    } catch (error) {
+      throw new Error(`Failed to parse Gherkin file: ${error.message}`);
+    }
+  }
+
+    /**
+   * Parse lines and build the test suite structure
+   * @param {string[]} lines
+   * @returns {Object}
+   */
+  parseLines(lines) {
+    /**
+     * @type {import('../../types').IManualTestSuite}
+     */
+    const testSuite = {
+      name: '',
+      type: 'feature',
+      tags: [],
+      before_each: [],
+      test_cases: []
+    };
+
+    let currentFeature = null;
+    let currentBackground = null;
+    let currentScenario = null;
+    let pendingFeatureTags = [];
+    let pendingScenarioTags = [];
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      if (line.startsWith('@')) {
+        // Handle tags
+        const tags = this.parseTags(line);
+
+        // Look ahead to see if tags belong to Feature or Scenario
+        if (i + 1 < lines.length && lines[i + 1].startsWith('Feature:')) {
+          // Tags belong to Feature
+          pendingFeatureTags = tags;
+        } else if (i + 1 < lines.length && lines[i + 1].startsWith('Scenario:')) {
+          // Tags belong to Scenario
+          pendingScenarioTags = tags;
+        }
+      } else if (line.startsWith('Feature:')) {
+        // Parse Feature
+        const description = this.parseMultiLineDescription(lines, i + 1);
+        currentFeature = this.parseFeature(line, description);
+        testSuite.name = currentFeature.name;
+        testSuite.tags = pendingFeatureTags.map(tag => tag.name);
+        pendingFeatureTags = [];
+        i += description.split('\n').length; // Skip all description lines
+      } else if (line.startsWith('Background:')) {
+        // Parse Background
+        currentBackground = this.parseBackground();
+        testSuite.before_each.push(currentBackground);
+      } else if (line.startsWith('Scenario:')) {
+        // Parse Scenario
+        currentScenario = this.parseScenario(line);
+        currentScenario.tags = pendingScenarioTags.map(tag => tag.name);
+        testSuite.test_cases.push(currentScenario);
+        pendingScenarioTags = [];
+        currentBackground = null; // Reset Background context when Scenario starts
+      } else if (this.isStep(line)) {
+        // Parse Step
+        const step = this.parseStep(line);
+
+        // Determine where to add the step based on current context
+        if (currentBackground && currentBackground.steps) {
+          // Add step to Background
+          currentBackground.steps.push(step);
+        } else if (currentScenario && currentScenario.steps) {
+          // Add step to Scenario
+          currentScenario.steps.push(step);
+        }
+      }
+    }
+
+    for (const testCase of testSuite.test_cases) {
+      testCase.hash = this.hashTestCase(testCase);
+    }
+    testSuite.hash = this.hashTestSuite(testSuite);
+
+    return testSuite;
+  }
+
+  /**
+   * Parse tags from a line
+   * @param {string} line
+   * @returns {Array}
+   */
+  parseTags(line) {
+    const tagMatches = line.match(/@\w+/g);
+    return tagMatches ? tagMatches.map(tag => ({ name: tag })) : [];
+  }
+
+  /**
+   * Parse multi-line description starting from a given line index
+   * @param {string[]} lines
+   * @param {number} startIndex
+   * @returns {string}
+   */
+  parseMultiLineDescription(lines, startIndex) {
+    const descriptionLines = [];
+
+    for (let i = startIndex; i < lines.length; i++) {
+      const line = lines[i];
+
+      // Stop if we hit a keyword or step
+      if (line.startsWith('Background:') ||
+          line.startsWith('Scenario:') ||
+          line.startsWith('@') ||
+          this.isStep(line)) {
+        break;
+      }
+
+      // Add non-empty lines to description
+      if (line.trim().length > 0) {
+        descriptionLines.push(line.trim());
+      }
+    }
+
+    return descriptionLines.join('\n');
+  }
+
+  /**
+   * Parse Feature line
+   * @param {string} line
+   * @param {string} description
+   * @returns {Object}
+   */
+  parseFeature(line, description) {
+    const name = line.replace('Feature:', '').trim();
+    return {
+      type: 'Feature',
+      tags: [],
+      keyword: 'Feature',
+      name: name,
+      description: description.trim(),
+      children: []
+    };
+  }
+
+  /**
+   * Parse Background line
+   * @returns {Object}
+   */
+  parseBackground() {
+    return {
+      name: '',
+      type: 'background',
+      steps: []
+    };
+  }
+
+  /**
+   * Parse Scenario line
+   * @param {string} line
+   * @returns {import('../../types').IManualTestCase}
+   */
+  parseScenario(line) {
+    const name = line.replace('Scenario:', '').trim();
+    return {
+      name: name,
+      type: 'scenario',
+      tags: [],
+      steps: []
+    };
+  }
+
+  /**
+   * Check if a line is a step
+   * @param {string} line
+   * @returns {boolean}
+   */
+  isStep(line) {
+    return this.stepKeywords.some(keyword =>
+      line.startsWith(keyword + ' ') ||
+      line.startsWith('And ') ||
+      line.startsWith('But ')
+    );
+  }
+
+  /**
+   * Parse a step line
+   * @param {string} line
+   * @returns {Object}
+   */
+  parseStep(line) {
+    return {
+      name: line.trim()
+    };
+  }
+
+  /**
+   * Parse from string content instead of file
+   * @param {string} content
+   * @returns {Object} Parsed test suite structure
+   */
+  parseString(content) {
+    try {
+      const lines = content.split('\n').map(line => line.trim()).filter(line => line.length > 0);
+      return this.parseLines(lines);
+    } catch (error) {
+      throw new Error(`Failed to parse Gherkin content: ${error.message}`);
+    }
+  }
+
+  /**
+   * Validate if the parsed document has required structure
+   * @param {Object} document
+   * @returns {boolean}
+   */
+  validate(document) {
+    return document &&
+           document.name &&
+           document.type === 'feature' &&
+           Array.isArray(document.tags) &&
+           Array.isArray(document.before_each) &&
+           Array.isArray(document.test_cases);
+  }
+}
+
+module.exports = { GherkinParser };

package/src/manual/sync.helper.js

@@ -0,0 +1,193 @@
+const fs = require('fs');
+const path = require('path');
+const hash = require('object-hash');
+const { GherkinParser } = require('./parsers/gherkin');
+
+class ManualSyncHelper {
+  constructor() {
+    this.parser = new GherkinParser();
+  }
+
+  /**
+   * Generate hash for an object
+   * @param {Object} obj - Object to hash
+   * @returns {string} Hash string
+   */
+  generateHash(obj) {
+    return hash(obj, { algorithm: 'md5' });
+  }
+
+  /**
+   * Add hash to test case
+   * @param {Object} testCase - Test case object
+   * @returns {Object} Test case with hash
+   */
+  addTestCaseHash(testCase) {
+    return {
+      ...testCase,
+      hash: this.generateHash(testCase)
+    };
+  }
+
+  /**
+   * Add hash to test suite
+   * @param {Object} testSuite - Test suite object
+   * @returns {Object} Test suite with hash
+   */
+  addTestSuiteHash(testSuite) {
+    return {
+      ...testSuite,
+      hash: this.generateHash(testSuite),
+      test_cases: testSuite.test_cases.map(testCase => this.addTestCaseHash(testCase))
+    };
+  }
+
+  /**
+   * Add hash to folder
+   * @param {Object} folder - Folder object
+   * @returns {Object} Folder with hash
+   */
+  addFolderHash(folder) {
+    return {
+      ...folder,
+      hash: this.generateHash(folder),
+      test_suites: folder.test_suites.map(testSuite => this.addTestSuiteHash(testSuite)),
+      folders: folder.folders.map(subFolder => this.addFolderHash(subFolder))
+    };
+  }
+
+  /**
+   * Hash a folder
+   * @param {import('../types').IManualTestFolder} folder
+   * @returns {string} Hash string
+   */
+  hashFolder(folder) {
+    return this.generateHash({
+      name: folder.name,
+      path: folder.path,
+      test_suites: folder.test_suites.map(testSuite => testSuite.hash),
+      folders: folder.folders.map(subFolder => subFolder.hash)
+    });
+  }
+
+  /**
+   * Hash a test suite
+   * @param {import('../types').IManualTestSuite} testSuite
+   * @returns {string} Hash string
+   */
+  hashTestSuite(testSuite) {
+    return this.generateHash({
+      name: testSuite.name,
+      tags: testSuite.tags,
+      before_each: testSuite.before_each,
+      test_cases: testSuite.test_cases.map(testCase => testCase.hash)
+    });
+  }
+
+
+  /**
+   * Scan directory recursively and build folder structure
+   * @param {string} directoryPath - Path to scan
+   * @returns {Object} Folder structure with test suites and hashes
+   */
+  async scanDirectory(directoryPath) {
+    const absolutePath = path.resolve(directoryPath);
+
+    if (!fs.existsSync(absolutePath)) {
+      throw new Error(`Directory does not exist: ${directoryPath}`);
+    }
+
+    if (!fs.statSync(absolutePath).isDirectory()) {
+      throw new Error(`Path is not a directory: ${directoryPath}`);
+    }
+
+    return this.buildFolderStructure(absolutePath, directoryPath);
+  }
+
+  /**
+   * Build folder structure recursively
+   * @param {string} absolutePath - Absolute path for file operations
+   * @param {string} relativePath - Relative path for output
+   * @returns {import('../types').IManualTestFolder} Folder structure
+   */
+  buildFolderStructure(absolutePath, relativePath) {
+    const folderName = path.basename(absolutePath);
+    const items = fs.readdirSync(absolutePath);
+
+    /**
+     * @type {import('../types').IManualTestFolder}
+     */
+    const structure = {
+      name: folderName,
+      path: relativePath,
+      test_suites: [],
+      folders: []
+    };
+
+    for (const item of items) {
+      const itemPath = path.join(absolutePath, item);
+      const itemRelativePath = path.join(relativePath, item);
+      const stats = fs.statSync(itemPath);
+
+      if (stats.isDirectory()) {
+        // Recursively process subdirectories
+        const subFolder = this.buildFolderStructure(itemPath, itemRelativePath);
+        structure.folders.push(subFolder);
+      } else if (this.isGherkinFile(item)) {
+        // Parse gherkin files
+        try {
+          const testSuite = this.parseGherkinFile(itemPath, itemRelativePath);
+          testSuite.hash = this.hashTestSuite(testSuite);
+          structure.test_suites.push(testSuite);
+        } catch (error) {
+          console.warn(`Warning: Failed to parse ${itemPath}: ${error.message}`);
+        }
+      }
+    }
+    structure.hash = this.hashFolder(structure);
+    if (structure.test_suites.length > 0) {
+      const defaultFolder = {
+        name: 'default',
+        path: 'default',
+        hash: '',
+        test_suites: structure.test_suites,
+        folders: []
+      };
+      defaultFolder.hash = this.hashFolder(defaultFolder);
+      structure.folders.push(defaultFolder);
+      structure.test_suites = [];
+    }
+
+    return structure;
+  }
+
+  /**
+   * Check if file is a gherkin file
+   * @param {string} filename - Filename to check
+   * @returns {boolean} True if gherkin file
+   */
+  isGherkinFile(filename) {
+    return filename.endsWith('.feature');
+  }
+
+  /**
+   * Parse a gherkin file and format output
+   * @param {string} filePath - Path to gherkin file
+   * @param {string} relativePath - Relative path for output
+   * @returns {import('../types').IManualTestSuite} Formatted test suite
+   */
+  parseGherkinFile(filePath, relativePath) {
+    const parsed = this.parser.parse(filePath);
+
+    return {
+      name: parsed.name,
+      type: parsed.type,
+      tags: parsed.tags,
+      before_each: parsed.before_each,
+      path: relativePath,
+      test_cases: parsed.test_cases || [] // Map 'cases' to 'test_cases' for consistency
+    };
+  }
+}
+
+module.exports = { ManualSyncHelper };

package/src/targets/github-output.target.js

@@ -0,0 +1,64 @@
+const fs = require('fs');
+const path = require('path');
+const logger = require('../utils/logger');
+const { BaseTarget } = require('./base.target');
+const context = require('../utils/context.utils');
+
+const DEFAULT_INPUTS = {
+  output_file: process.env.GITHUB_OUTPUT, // Path to output file, defaults to GITHUB_OUTPUT env var
+  key: 'testbeats' // Key name for the output
+};
+
+const default_options = {
+  condition: 'passOrFail'
+};
+
+class GitHubOutputTarget extends BaseTarget {
+  constructor({ target }) {
+    super({ target });
+  }
+
+  async run({ result, target }) {
+    this.result = result;
+    this.setTargetInputs(target);
+
+    logger.info(`🔔 Writing results to GitHub Actions outputs...`);
+    return await this.writeToGitHubOutput({ target, result });
+  }
+
+  setTargetInputs(target) {
+    target.inputs = Object.assign({}, DEFAULT_INPUTS, target.inputs);
+  }
+
+  async writeToGitHubOutput({ target, result }) {
+    const outputFile = target.inputs.output_file || process.env.GITHUB_OUTPUT;
+
+    if (!outputFile) {
+      throw new Error('GitHub output file path is required. Set GITHUB_OUTPUT environment variable or provide output_file in target inputs.');
+    }
+
+    // Ensure the directory exists
+    const outputDir = path.dirname(outputFile);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    const lines = []
+    lines.push(`${target.inputs.key}_results=${JSON.stringify(result)}`)
+    lines.push(`${target.inputs.key}_stores=${JSON.stringify(context.stores)}`)
+    const outputContent = lines.join('\n');
+
+    fs.appendFileSync(outputFile, outputContent);
+
+    logger.info(`✅ Successfully wrote results to ${outputFile}`);
+    return { success: true, key: target.inputs.key };
+  }
+
+  async handleErrors({ target, errors }) {
+    logger.error('GitHub Output target errors:', errors);
+  }
+}
+
+module.exports = {
+  GitHubOutputTarget
+};

package/src/targets/index.js

@@ -2,6 +2,7 @@ const teams = require('./teams');
 const slack = require('./slack');
 const chat = require('./chat');
 const { GitHubTarget} = require('./github.target');
+const { GitHubOutputTarget } = require('./github-output.target');
 const { CustomTarget } = require('./custom.target');
 const { DelayTarget } = require('./delay.target');
 const { HttpTarget } = require('./http.target');
@@ -19,6 +20,8 @@ function getTargetRunner(target) {
       return chat;
     case TARGET.GITHUB:
       return new GitHubTarget({ target });
+    case TARGET.GITHUB_OUTPUT:
+      return new GitHubOutputTarget({ target });
     case TARGET.CUSTOM:
       return new CustomTarget({ target });
     case TARGET.DELAY:

package/src/types.d.ts

@@ -0,0 +1,104 @@
+export type IManualTestCase = {
+  name: string;
+  type: string;
+  tags: string[];
+  steps: string[];
+  path: string;
+  hash: string;
+}
+
+export type IManualTestSuite = {
+  name: string;
+  type: string;
+  tags: string[];
+  before_each: string[];
+  test_cases: IManualTestCase[];
+  hash: string;
+}
+
+export type IManualTestFolder = {
+  name: string;
+  path: string;
+  test_suites: IManualTestSuite[];
+  folders: IManualTestFolder[];
+  hash: string;
+}
+
+export type IManualSyncComparePayload = {
+  project_id: string;
+  folders: IManualSyncCompareFolder[];
+}
+
+export type IManualSyncCompareFolder = {
+  name: string;
+  hash: string;
+  test_suites: IManualSyncCompareTestSuite[];
+  folders: IManualSyncCompareFolder[];
+}
+
+export type IManualSyncCompareTestSuite = {
+  name: string;
+  hash: string;
+}
+
+export type IManualSyncCompareTestCase = {
+  name: string;
+  hash: string;
+}
+
+export type IManualSyncCompareResponse = {
+  folders: IManualSyncCompareResponseFolder[];
+}
+
+export type SyncOperationType = 'create' | 'update' | 'delete' | 'no_change';
+
+export type IManualSyncCompareResponseFolder = {
+  type: SyncOperationType;
+  id?: string;
+  name: string;
+  hash: string;
+  test_suites: IManualSyncCompareResponseTestSuite[];
+  folders: IManualSyncCompareResponseFolder[];
+}
+
+export type IManualSyncCompareResponseTestSuite = {
+  type: SyncOperationType;
+  id?: string;
+  name: string;
+  hash: string;
+}
+
+export type IManualSyncFoldersPayload = {
+  project_id: string;
+  folders: IManualSyncFoldersFolder[];
+}
+
+export type IManualSyncFoldersFolder = {
+  type: SyncOperationType;
+  name: string;
+  path: string;
+  hash: string;
+  id?: string;
+}
+
+export type ISyncManualSuitesPayload = {
+  project_id: string;
+  suites: ISyncManualSuitesSuite[];
+}
+
+export type ISyncManualSuitesSuite = {
+  type: SyncOperationType;
+  name: string;
+  folder_id: string;
+  hash: string;
+  tags?: string[];
+  before_each?: string[];
+  test_cases?: ISyncManualSuitesTestCase[];
+}
+
+export type ISyncManualSuitesTestCase = {
+  name: string;
+  hash: string;
+  tags?: string[];
+  steps: string[];
+}