@outputai/core 0.7.1-next.ae5bab4.0 → 0.7.1-next.ba2fb0b.0

package/src/worker/loader/activities.js

@@ -0,0 +1,75 @@
+import { dirname } from 'node:path';
+import { getTraceDestinations, sendHttpRequest } from '#internal_activities';
+import { findSharedActivitiesFromWorkflows, importComponents, matchFiles, writeFileInTempDir } from './tools.js';
+import { buildActivityMatcher, staticMatchers } from './matchers.js';
+import { ACTIVITY_SEND_HTTP_REQUEST, ACTIVITY_OPTIONS_FILENAME, SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS } from '#consts';
+import { createChildLogger } from '#logger';
+import { ValidationError } from '#errors';
+
+const log = createChildLogger( 'Activities Loader' );
+
+/**
+ * Load activities:
+ * - Scans activities based on workflows, using each workflow folder as a point to lookup for steps, evaluators files;
+ * - Scans shared activities in the rootDir;
+ * - Loads internal activities as well;
+ *
+ * Builds a map of activities, where they is generated according to the type of activity and the value is the function itself and return it.
+ * - Shared activity keys have a common prefix followed by the activity name;
+ * - Internal activities are registered with a fixed key;
+ * - Workflow activities keys are composed using the workflow name and the activity name;
+ *
+ * @param {string} rootDir
+ * @param {import('./workflows.js').Workflow[]} workflows
+ * @returns {object}
+ */
+export async function loadActivities( rootDir, workflows ) {
+  const activities = {};
+  const activityOptionsMap = {};
+
+  // Load workflow-based activities
+  for ( const { path: workflowPath, name: workflowName, external } of workflows ) {
+    const dir = dirname( workflowPath );
+    for await ( const { fn, metadata, path } of importComponents( matchFiles( dir, [ buildActivityMatcher( dir ) ] ) ) ) {
+      // Activities loaded from a workflow path will use the workflow name as a namespace, which is unique across the platform, avoiding collision
+      const activityKey = `${workflowName}#${metadata.name}`;
+
+      log.info( metadata.name, { workflow: workflowName, type: metadata.type, ...( external && { external } ), path } );
+
+      if ( activities[activityKey] ) {
+        throw new ValidationError( `Activity "${metadata.name}" in workflow "${workflowName}" conflicts with another \
+activity in the same workflow. Activity names must be unique within a workflow.` );
+      }
+      activities[activityKey] = fn;
+      // propagate the custom options set on the step()/evaluator() constructor
+      activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
+    }
+  }
+
+  // Load shared activities/evaluators from local and external npm modules
+  const localSharedActivities = matchFiles( rootDir, [ staticMatchers.sharedStepsDir, staticMatchers.sharedEvaluatorsDir ] );
+  const externalSharedActivities = findSharedActivitiesFromWorkflows( workflows.filter( w => w.external ) );
+  for await ( const { fn, metadata, path } of importComponents( [ ...localSharedActivities, ...externalSharedActivities ] ) ) {
+    const external = externalSharedActivities.some( a => a.path === path );
+    // Uses a global namespace for shared activities
+    const activityKey = `${SHARED_STEP_PREFIX}#${metadata.name}`;
+
+    log.info( metadata.name, { shared: true, type: metadata.type, ...( external && { external } ), path } );
+
+    if ( activities[activityKey] ) {
+      throw new ValidationError( `Shared activity "${metadata.name}" conflicts with another shared activity. \
+Shared activity names must be unique.` );
+    }
+    activities[activityKey] = fn;
+    activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
+  }
+
+  // writes down the activity option overrides
+  const optionsContent = `export default ${JSON.stringify( activityOptionsMap, undefined, 2 )};`;
+  const optionsFile = writeFileInTempDir( optionsContent, ACTIVITY_OPTIONS_FILENAME );
+
+  // system activities
+  activities[ACTIVITY_SEND_HTTP_REQUEST] = sendHttpRequest;
+  activities[ACTIVITY_GET_TRACE_DESTINATIONS] = getTraceDestinations;
+  return { activities, optionsFile };
+};

package/src/worker/loader/activities.spec.js

@@ -0,0 +1,213 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock( '#consts', () => ( {
+  ACTIVITY_SEND_HTTP_REQUEST: '__internal#sendHttpRequest',
+  ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
+  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
+  WORKFLOW_CATALOG: 'catalog',
+  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
+  SHARED_STEP_PREFIX: '$shared'
+} ) );
+
+const sendHttpRequestMock = vi.fn();
+const getTraceDestinationsMock = vi.fn();
+vi.mock( '#internal_activities', () => ( {
+  sendHttpRequest: sendHttpRequestMock,
+  getTraceDestinations: getTraceDestinationsMock
+} ) );
+
+const { importComponentsMock, findSharedActivitiesFromWorkflowsMock, matchFilesMock, writeFileInTempDirMock } = vi.hoisted( () => ( {
+  importComponentsMock: vi.fn(),
+  findSharedActivitiesFromWorkflowsMock: vi.fn(),
+  matchFilesMock: vi.fn(),
+  writeFileInTempDirMock: vi.fn()
+} ) );
+
+const { buildActivityMatcherMock, activityMatcherMock, sharedStepsDirMock, sharedEvaluatorsDirMock } = vi.hoisted( () => ( {
+  buildActivityMatcherMock: vi.fn(),
+  activityMatcherMock: vi.fn(),
+  sharedStepsDirMock: vi.fn(),
+  sharedEvaluatorsDirMock: vi.fn()
+} ) );
+
+vi.mock( './tools.js', () => ( {
+  importComponents: importComponentsMock,
+  findSharedActivitiesFromWorkflows: findSharedActivitiesFromWorkflowsMock,
+  matchFiles: matchFilesMock,
+  writeFileInTempDir: writeFileInTempDirMock
+} ) );
+
+vi.mock( './matchers.js', () => ( {
+  buildActivityMatcher: buildActivityMatcherMock,
+  staticMatchers: {
+    sharedStepsDir: sharedStepsDirMock,
+    sharedEvaluatorsDir: sharedEvaluatorsDirMock
+  }
+} ) );
+
+describe( 'loadActivities', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    importComponentsMock.mockReset();
+    importComponentsMock.mockImplementation( async function *() {} );
+    findSharedActivitiesFromWorkflowsMock.mockReset();
+    findSharedActivitiesFromWorkflowsMock.mockReturnValue( [] );
+    matchFilesMock.mockReset();
+    matchFilesMock.mockReturnValue( [] );
+    writeFileInTempDirMock.mockReset();
+    writeFileInTempDirMock.mockReturnValue( '/tmp/__activity_options.js' );
+    buildActivityMatcherMock.mockReset();
+    buildActivityMatcherMock.mockReturnValue( activityMatcherMock );
+  } );
+
+  it( 'loadActivities returns map including system activity and writes options file', async () => {
+    const { loadActivities } = await import( './activities.js' );
+
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield {
+        fn: () => {},
+        metadata: { name: 'Act1', options: { activityOptions: { retry: { maximumAttempts: 3 } } } },
+        path: '/a/steps.js'
+      };
+    } );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+
+    const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
+    const { activities, optionsFile } = await loadActivities( '/root', workflows );
+    expect( activities['A#Act1'] ).toBeTypeOf( 'function' );
+    expect( activities['__internal#sendHttpRequest'] ).toBe( sendHttpRequestMock );
+    expect( optionsFile ).toBe( '/tmp/__activity_options.js' );
+
+    expect( writeFileInTempDirMock ).toHaveBeenCalledTimes( 1 );
+    const [ contents, filename ] = writeFileInTempDirMock.mock.calls[0];
+    expect( filename ).toBe( '__activity_options.js' );
+    expect( contents ).toContain( 'export default' );
+    expect( JSON.parse( contents.replace( /^export default\s*/, '' ).replace( /;\s*$/, '' ) ) ).toEqual( {
+      'A#Act1': { retry: { maximumAttempts: 3 } }
+    } );
+  } );
+
+  it( 'loadActivities omits activity options when component has no options or no activityOptions', async () => {
+    const { loadActivities } = await import( './activities.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'NoOptions' }, path: '/a/steps.js' };
+      yield { fn: () => {}, metadata: { name: 'EmptyOptions', options: {} }, path: '/a/steps2.js' };
+    } );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+
+    await loadActivities( '/root', [ { name: 'A', path: '/a/workflow.js' } ] );
+    const written = JSON.parse(
+      writeFileInTempDirMock.mock.calls[0][0].replace( /^export default\s*/, '' ).replace( /;\s*$/, '' )
+    );
+    expect( written['A#NoOptions'] ).toBeUndefined();
+    expect( written['A#EmptyOptions'] ).toBeUndefined();
+  } );
+
+  it( 'loadActivities throws when two activities in the same workflow share a name', async () => {
+    const { loadActivities } = await import( './activities.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'DuplicateActivity' }, path: '/a/steps.js' };
+      yield { fn: () => {}, metadata: { name: 'DuplicateActivity' }, path: '/a/evaluators.js' };
+    } );
+
+    await expect( loadActivities( '/root', [ { name: 'A', path: '/a/workflow.js' } ] ) ).rejects.toThrow(
+      'Activity "DuplicateActivity" in workflow "A" conflicts with another activity in the same workflow. \
+Activity names must be unique within a workflow.'
+    );
+  } );
+
+  it( 'loadActivities throws when two shared activities share a name', async () => {
+    const { loadActivities } = await import( './activities.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'DuplicateShared' }, path: '/root/shared/steps/a.js' };
+      yield { fn: () => {}, metadata: { name: 'DuplicateShared' }, path: '/root/shared/evaluators/a.js' };
+    } );
+
+    await expect( loadActivities( '/root', [ { name: 'A', path: '/a/workflow.js' } ] ) ).rejects.toThrow(
+      'Shared activity "DuplicateShared" conflicts with another shared activity. Shared activity names must be unique.'
+    );
+  } );
+
+  it( 'loadActivities uses activity and shared matchers for workflow and shared scans', async () => {
+    const { loadActivities } = await import( './activities.js' );
+    const workflowFiles = [ { path: '/a/steps/foo.js' } ];
+    const sharedFiles = [ { path: '/root/shared/steps/baz.js' } ];
+    matchFilesMock.mockReturnValueOnce( workflowFiles );
+    matchFilesMock.mockReturnValueOnce( sharedFiles );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+
+    const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
+    await loadActivities( '/root', workflows );
+
+    expect( matchFilesMock ).toHaveBeenCalledTimes( 2 );
+    expect( buildActivityMatcherMock ).toHaveBeenCalledWith( '/a' );
+    expect( matchFilesMock ).toHaveBeenNthCalledWith( 1, '/a', [ activityMatcherMock ] );
+    expect( matchFilesMock ).toHaveBeenNthCalledWith( 2, '/root', [ sharedStepsDirMock, sharedEvaluatorsDirMock ] );
+
+    expect( importComponentsMock ).toHaveBeenCalledTimes( 2 );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, workflowFiles );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 2, sharedFiles );
+  } );
+
+  it( 'loads shared activities from external workflow packages', async () => {
+    const { loadActivities } = await import( './activities.js' );
+    const externalSharedFiles = [ { path: '/root/node_modules/pkg/shared/steps/prepare.js' } ];
+    const localWorkflow = { name: 'Local', path: '/root/workflows/local/workflow.js' };
+    const externalWorkflow = { name: 'External', path: '/root/node_modules/pkg/workflows/a/workflow.js', external: true };
+    findSharedActivitiesFromWorkflowsMock.mockReturnValue( externalSharedFiles );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield {
+        fn: () => {},
+        metadata: { name: 'ExternalShared', options: { activityOptions: { retry: { maximumAttempts: 2 } } } },
+        path: '/root/node_modules/pkg/shared/steps/prepare.js'
+      };
+    } );
+
+    const { activities } = await loadActivities( '/root', [ localWorkflow, externalWorkflow ] );
+
+    expect( findSharedActivitiesFromWorkflowsMock ).toHaveBeenCalledWith( [ externalWorkflow ] );
+    expect( importComponentsMock ).toHaveBeenNthCalledWith( 3, externalSharedFiles );
+    expect( activities['$shared#ExternalShared'] ).toBeTypeOf( 'function' );
+    const written = JSON.parse(
+      writeFileInTempDirMock.mock.calls[0][0].replace( /^export default\s*/, '' ).replace( /;\s*$/, '' )
+    );
+    expect( written['$shared#ExternalShared'] ).toEqual( { retry: { maximumAttempts: 2 } } );
+  } );
+
+  it( 'loadActivities includes nested workflow steps and shared evaluators', async () => {
+    const { loadActivities } = await import( './activities.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'ActNested' }, path: '/a/steps/foo.js' };
+    } );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'SharedEval' }, path: '/root/shared/evaluators/bar.js' };
+    } );
+
+    const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
+    const { activities } = await loadActivities( '/root', workflows );
+    expect( activities['A#ActNested'] ).toBeTypeOf( 'function' );
+    expect( activities['$shared#SharedEval'] ).toBeTypeOf( 'function' );
+  } );
+
+  it( 'collects shared nested steps and evaluators across multiple subfolders', async () => {
+    const { loadActivities } = await import( './activities.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'SharedStepPrimary' }, path: '/root/shared/steps/primary/a.js' };
+      yield { fn: () => {}, metadata: { name: 'SharedStepSecondary' }, path: '/root/shared/steps/secondary/b.js' };
+      yield { fn: () => {}, metadata: { name: 'SharedEvalPrimary' }, path: '/root/shared/evaluators/primary/c.js' };
+      yield { fn: () => {}, metadata: { name: 'SharedEvalSecondary' }, path: '/root/shared/evaluators/secondary/d.js' };
+    } );
+
+    const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
+    const { activities } = await loadActivities( '/root', workflows );
+    expect( activities['$shared#SharedStepPrimary'] ).toBeTypeOf( 'function' );
+    expect( activities['$shared#SharedStepSecondary'] ).toBeTypeOf( 'function' );
+    expect( activities['$shared#SharedEvalPrimary'] ).toBeTypeOf( 'function' );
+    expect( activities['$shared#SharedEvalSecondary'] ).toBeTypeOf( 'function' );
+  } );
+} );

package/src/worker/loader/hooks.js

@@ -0,0 +1,28 @@
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createChildLogger } from '#logger';
+
+const log = createChildLogger( 'Hooks Loader' );
+
+/**
+ * Loads the hook files from package.json's "outputai" section.
+ *
+ * @param {string} rootDir
+ * @returns {void}
+ */
+export async function loadHooks( rootDir ) {
+  const packageFile = join( rootDir, 'package.json' );
+  if ( existsSync( packageFile ) ) {
+    const pkg = await import( packageFile, { with: { type: 'json' } } );
+    const content = pkg.default;
+    const hooks = [];
+    // @DEPRECATED: "output" is the legacy namespace for configs, can be removed after couple version (this is being added in 0.3.x)
+    hooks.push( ...( content['output']?.hookFiles ?? [] ) );
+    hooks.push( ...( content['outputai']?.hookFiles ?? [] ) );
+    for ( const path of hooks ) {
+      const hookFile = join( rootDir, path );
+      await import( hookFile );
+      log.info( 'Hook file loaded', { path } );
+    }
+  }
+};

package/src/worker/loader/hooks.spec.js

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const fsMocks = vi.hoisted( () => ( {
+  existsSync: vi.fn().mockReturnValue( false )
+} ) );
+vi.mock( 'node:fs', () => ( {
+  existsSync: fsMocks.existsSync
+} ) );
+
+describe( 'loadHooks', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    fsMocks.existsSync.mockReturnValue( false );
+  } );
+
+  it( 'resolves without importing when package.json does not exist', async () => {
+    fsMocks.existsSync.mockReturnValue( false );
+    const { loadHooks } = await import( './hooks.js' );
+    await expect( loadHooks( '/root' ) ).resolves.toBeUndefined();
+    expect( fsMocks.existsSync ).toHaveBeenCalledWith( join( '/root', 'package.json' ) );
+  } );
+
+  it( 'imports hook files listed in package.json outputai.hookFiles', async () => {
+    vi.doUnmock( 'node:fs' );
+    vi.resetModules();
+    const fs = await import( 'node:fs' );
+    const tmpDir = fs.mkdtempSync( join( tmpdir(), 'loader-spec-' ) );
+    try {
+      fs.writeFileSync( join( tmpDir, 'package.json' ), JSON.stringify( {
+        outputai: { hookFiles: [ 'hook.js' ] }
+      } ) );
+      fs.writeFileSync( join( tmpDir, 'hook.js' ), 'globalThis.__loadHooksTestLoaded = true;' );
+
+      const { loadHooks } = await import( './hooks.js' );
+      await loadHooks( tmpDir );
+      expect( globalThis.__loadHooksTestLoaded ).toBe( true );
+    } finally {
+      delete globalThis.__loadHooksTestLoaded;
+      fs.rmSync( tmpDir, { recursive: true, force: true } );
+    }
+  } );
+
+  it( 'imports hook files from legacy package.json output.hookFiles', async () => {
+    vi.doUnmock( 'node:fs' );
+    vi.resetModules();
+    const fs = await import( 'node:fs' );
+    const tmpDir = fs.mkdtempSync( join( tmpdir(), 'loader-spec-' ) );
+    try {
+      fs.writeFileSync( join( tmpDir, 'package.json' ), JSON.stringify( {
+        output: { hookFiles: [ 'legacy_hook.js' ] }
+      } ) );
+      fs.writeFileSync( join( tmpDir, 'legacy_hook.js' ), 'globalThis.__loadHooksLegacyTestLoaded = true;' );
+
+      const { loadHooks } = await import( './hooks.js' );
+      await loadHooks( tmpDir );
+      expect( globalThis.__loadHooksLegacyTestLoaded ).toBe( true );
+    } finally {
+      delete globalThis.__loadHooksLegacyTestLoaded;
+      fs.rmSync( tmpDir, { recursive: true, force: true } );
+    }
+  } );
+} );

package/src/worker/loader/matchers.js

@@ -0,0 +1,46 @@
+import { sep } from 'node:path';
+import { rxEscape } from '#utils';
+
+/**
+ * Creates a matcher function that based on "path", matches:
+ * - path/steps.js
+ * - path/evaluators.js
+ * - path/steps/*
+ * - path/evaluators/*
+ * @param {string} path
+ * @returns {function(string): boolean}
+ */
+export const buildActivityMatcher = path => {
+  const exp = new RegExp( `^${rxEscape( `${path}${sep}` )}(?:steps|evaluators)(?:\\.js$|${rxEscape( sep )})` );
+  return v => exp.test( v );
+};
+
+/**
+ * Matchers that can be used to access conditions without initializing them
+ */
+export const staticMatchers = {
+  /**
+   * Matches a workflow.js file
+   * @param {string} path - Path to test
+   * @returns {boolean}
+   */
+  workflowFile: v => v.endsWith( `${sep}workflow.js` ),
+  /**
+   * Matches a workflow.js that is inside a shared folder: eg foo/shared/workflow.js
+   * @param {string} path - Path to test
+   * @returns {boolean}
+   */
+  workflowPathHasShared: v => v.endsWith( `${sep}shared${sep}workflow.js` ),
+  /**
+   * Matches the shared folder for steps src/shared/steps/../step_file.js
+   * @param {string} path - Path to test
+   * @returns {boolean}
+   */
+  sharedStepsDir: v => v.includes( `${sep}shared${sep}steps${sep}` ) && v.endsWith( '.js' ),
+  /**
+   * Matches the shared folder for evaluators src/shared/evaluators/../evaluator_file.js
+   * @param {string} path - Path to test
+   * @returns {boolean}
+   */
+  sharedEvaluatorsDir: v => v.includes( `${sep}shared${sep}evaluators${sep}` ) && v.endsWith( '.js' )
+};

package/src/worker/loader/matchers.spec.js

@@ -0,0 +1,140 @@
+import { describe, it, expect } from 'vitest';
+import { sep } from 'node:path';
+import { buildActivityMatcher, staticMatchers } from './matchers.js';
+
+describe( 'buildActivityMatcher', () => {
+  const base = `${sep}app${sep}proj`;
+
+  it( 'matches steps.js at the base path', () => {
+    const matchActivity = buildActivityMatcher( base );
+
+    expect( matchActivity( `${base}${sep}steps.js` ) ).toBe( true );
+  } );
+
+  it( 'matches evaluators.js at the base path', () => {
+    const matchActivity = buildActivityMatcher( base );
+
+    expect( matchActivity( `${base}${sep}evaluators.js` ) ).toBe( true );
+  } );
+
+  it( 'matches files under the steps directory', () => {
+    const matchActivity = buildActivityMatcher( base );
+
+    expect( matchActivity( `${base}${sep}steps${sep}a.js` ) ).toBe( true );
+    expect( matchActivity( `${base}${sep}steps${sep}sub${sep}b.js` ) ).toBe( true );
+  } );
+
+  it( 'matches files under the evaluators directory', () => {
+    const matchActivity = buildActivityMatcher( base );
+
+    expect( matchActivity( `${base}${sep}evaluators${sep}x.js` ) ).toBe( true );
+    expect( matchActivity( `${base}${sep}evaluators${sep}y${sep}z.js` ) ).toBe( true );
+  } );
+
+  it( 'rejects activity filenames outside the base path', () => {
+    const matchActivity = buildActivityMatcher( base );
+
+    expect( matchActivity( `${base}${sep}nested${sep}steps.js` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}sub${sep}evaluators.js` ) ).toBe( false );
+    expect( matchActivity( `${sep}app${sep}other${sep}steps.js` ) ).toBe( false );
+  } );
+
+  it( 'rejects non-activity names at the base path', () => {
+    const matchActivity = buildActivityMatcher( base );
+
+    expect( matchActivity( `${base}${sep}workflow.js` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}shared${sep}steps${sep}a.js` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}other${sep}a.js` ) ).toBe( false );
+  } );
+
+  it( 'rejects similarly named files and directories', () => {
+    const matchActivity = buildActivityMatcher( base );
+
+    expect( matchActivity( `${base}${sep}stepsXjs` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}evaluatorsXjs` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}steps-extra.js` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}evaluators-extra.js` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}steps_extra${sep}a.js` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}evaluators_extra${sep}a.js` ) ).toBe( false );
+  } );
+
+  it( 'rejects directory names without a nested path', () => {
+    const matchActivity = buildActivityMatcher( base );
+
+    expect( matchActivity( `${base}${sep}steps` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}evaluators` ) ).toBe( false );
+  } );
+
+  it( 'rejects exact files when additional path segments follow', () => {
+    const matchActivity = buildActivityMatcher( base );
+
+    expect( matchActivity( `${base}${sep}steps.js${sep}extra.js` ) ).toBe( false );
+    expect( matchActivity( `${base}${sep}evaluators.js${sep}extra.js` ) ).toBe( false );
+  } );
+
+  it( 'escapes regular expression characters in the base path', () => {
+    const specialBase = `${sep}app${sep}proj.with-symbols+(test)`;
+    const matchActivity = buildActivityMatcher( specialBase );
+
+    expect( matchActivity( `${specialBase}${sep}steps.js` ) ).toBe( true );
+    expect( matchActivity( `${sep}app${sep}projXwith-symbols+(test)${sep}steps.js` ) ).toBe( false );
+  } );
+} );
+
+describe( 'staticMatchers', () => {
+  describe( 'workflowFile', () => {
+    it( 'matches paths ending with path separator and workflow.js', () => {
+      expect( staticMatchers.workflowFile( `${sep}x${sep}y${sep}workflow.js` ) ).toBe( true );
+    } );
+
+    it( 'rejects workflow.ts', () => {
+      expect( staticMatchers.workflowFile( `${sep}a${sep}workflow.ts` ) ).toBe( false );
+    } );
+  } );
+
+  describe( 'workflowPathHasShared', () => {
+    it( 'matches workflow.js under a shared folder segment', () => {
+      expect( staticMatchers.workflowPathHasShared( `${sep}foo${sep}shared${sep}workflow.js` ) ).toBe( true );
+    } );
+
+    it( 'rejects workflow.js not under shared', () => {
+      expect( staticMatchers.workflowPathHasShared( `${sep}foo${sep}workflow.js` ) ).toBe( false );
+    } );
+  } );
+
+  describe( 'sharedStepsDir', () => {
+    it( 'matches .js files inside shared/steps/', () => {
+      expect( staticMatchers.sharedStepsDir( `${sep}app${sep}dist${sep}shared${sep}steps${sep}tools.js` ) ).toBe( true );
+    } );
+
+    it( 'matches .js files in nested subdirectories of shared/steps/', () => {
+      expect( staticMatchers.sharedStepsDir( `${sep}app${sep}dist${sep}shared${sep}steps${sep}utils${sep}helper.js` ) ).toBe( true );
+    } );
+
+    it( 'rejects .ts files inside shared/steps/', () => {
+      expect( staticMatchers.sharedStepsDir( `${sep}app${sep}src${sep}shared${sep}steps${sep}tools.ts` ) ).toBe( false );
+    } );
+
+    it( 'rejects non-.js files inside shared/steps/', () => {
+      expect( staticMatchers.sharedStepsDir( `${sep}app${sep}dist${sep}shared${sep}steps${sep}readme.md` ) ).toBe( false );
+    } );
+  } );
+
+  describe( 'sharedEvaluatorsDir', () => {
+    it( 'matches .js files inside shared/evaluators/', () => {
+      expect( staticMatchers.sharedEvaluatorsDir( `${sep}app${sep}dist${sep}shared${sep}evaluators${sep}quality.js` ) ).toBe( true );
+    } );
+
+    it( 'matches .js files in nested subdirectories of shared/evaluators/', () => {
+      expect( staticMatchers.sharedEvaluatorsDir( `${sep}app${sep}dist${sep}shared${sep}evaluators${sep}utils${sep}helper.js` ) ).toBe( true );
+    } );
+
+    it( 'rejects .ts files inside shared/evaluators/', () => {
+      expect( staticMatchers.sharedEvaluatorsDir( `${sep}app${sep}src${sep}shared${sep}evaluators${sep}quality.ts` ) ).toBe( false );
+    } );
+
+    it( 'rejects non-.js files inside shared/evaluators/', () => {
+      expect( staticMatchers.sharedEvaluatorsDir( `${sep}app${sep}dist${sep}shared${sep}evaluators${sep}readme.md` ) ).toBe( false );
+    } );
+  } );
+} );

package/src/worker/{loader_tools.js → loader/tools.js}

@@ -1,8 +1,9 @@
-import { dirname, resolve, sep } from 'path';
-import { pathToFileURL } from 'url';
+import { join, dirname, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { METADATA_ACCESS_SYMBOL } from '#consts';
-import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync } from 'fs';
+import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, mkdirSync, writeFileSync } from 'node:fs';
 import { hashElement } from 'folder-hash';
+import { staticMatchers } from './matchers.js';
 
 /**
  * Returns the real path for symlink
@@ -20,69 +21,6 @@ export const resolveSymlink = link => {
   }
 };
 
-/**
- * Returns matchers that need to be built using a relative path
- *
- * @param {string} path
- * @returns {object} The object containing the matchers
- */
-export const activityMatchersBuilder = path => ( {
-  /**
-   * Matches a file called steps.js, located at the path
-   * @param {string} path - Path to test
-   * @returns {boolean}
-   */
-  stepsFile: v => v === `${path}${sep}steps.js`,
-  /**
-   * Matches a file called evaluators.js, located at the path
-   * @param {string} path - Path to test
-   * @returns {boolean}
-   */
-  evaluatorsFile: v => v === `${path}${sep}evaluators.js`,
-  /**
-   * Matches all files on any levels inside a folder called steps/, located at the path
-   * @param {string} path - Path to test
-   * @returns {boolean}
-   */
-  stepsDir: v => v.startsWith( `${path}${sep}steps${sep}` ),
-  /**
-   * Matches all files on any levels inside a folder called evaluators/, located at the path
-   * @param {string} path - Path to test
-   * @returns {boolean}
-   */
-  evaluatorsDir: v => v.startsWith( `${path}${sep}evaluators${sep}` )
-} );
-
-/**
- * Matchers that can be used to access conditions without initializing them
- */
-export const staticMatchers = {
-  /**
-   * Matches a workflow.js file
-   * @param {string} path - Path to test
-   * @returns {boolean}
-   */
-  workflowFile: v => v.endsWith( `${sep}workflow.js` ),
-  /**
-   * Matches a workflow.js that is inside a shared folder: eg foo/shared/workflow.js
-   * @param {string} path - Path to test
-   * @returns {boolean}
-   */
-  workflowPathHasShared: v => v.endsWith( `${sep}shared${sep}workflow.js` ),
-  /**
-   * Matches the shared folder for steps src/shared/steps/../step_file.js
-   * @param {string} path - Path to test
-   * @returns {boolean}
-   */
-  sharedStepsDir: v => v.includes( `${sep}shared${sep}steps${sep}` ) && v.endsWith( '.js' ),
-  /**
-   * Matches the shared folder for evaluators src/shared/evaluators/../evaluator_file.js
-   * @param {string} path - Path to test
-   * @returns {boolean}
-   */
-  sharedEvaluatorsDir: v => v.includes( `${sep}shared${sep}evaluators${sep}` ) && v.endsWith( '.js' )
-};
-
 /**
  * @typedef {object} File
  * @property {string} path - The file path
@@ -314,7 +252,7 @@ export const hashSourceCode = async rootDir => {
   try {
     const { hash } = await hashElement( rootDir, {
       folders: {
-        exclude: [ '.*', 'node_modules', 'test_coverage', 'vendor', 'test' ],
+        exclude: [ '.*', 'node_modules', 'test_coverage', 'vendor', 'test', 'logs', 'dist' ],
         ignoreRootName: true
       },
       files: {
@@ -327,3 +265,17 @@ export const hashSourceCode = async rootDir => {
     throw new Error( `Error calculating hash from "${error}": ${error.message}`, { cause: error } );
   }
 };
+
+/**
+ * Creates a file in the temp folder and returns its path
+ * @returns {string} Folder
+ */
+export const writeFileInTempDir = ( content, name ) => {
+  const here = dirname( fileURLToPath( import.meta.url ) );
+  const tempDir = join( here, '..', 'temp' );
+  mkdirSync( tempDir, { recursive: true } );
+
+  const filename = join( tempDir, name );
+  writeFileSync( filename, content, 'utf-8' );
+  return filename;
+};