@outputai/core 0.1.0

package/src/worker/loader.spec.js

@@ -0,0 +1,236 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+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 = vi.fn();
+vi.mock( './loader_tools.js', async importOriginal => {
+  const actual = await importOriginal();
+  return { ...actual, importComponents: importComponentsMock };
+} );
+
+const fsMocks = vi.hoisted( () => ( {
+  mkdirSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  existsSync: vi.fn().mockReturnValue( false )
+} ) );
+vi.mock( 'node:fs', () => ( {
+  mkdirSync: fsMocks.mkdirSync,
+  writeFileSync: fsMocks.writeFileSync,
+  existsSync: fsMocks.existsSync
+} ) );
+
+describe( 'worker/loader', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'loadActivities returns map including system activity and writes options file', async () => {
+    const { loadActivities } = await import( './loader.js' );
+
+    // First call: workflow directory scan (options.activityOptions propagated to activity options file)
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield {
+        fn: () => {},
+        metadata: { name: 'Act1', options: { activityOptions: { retry: { maximumAttempts: 3 } } } },
+        path: '/a/steps.js'
+      };
+    } );
+    // Second call: shared activities scan (no results)
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+
+    const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
+    const activities = await loadActivities( '/root', workflows );
+    expect( activities['A#Act1'] ).toBeTypeOf( 'function' );
+    expect( activities['__internal#sendHttpRequest'] ).toBe( sendHttpRequestMock );
+
+    // options file written with the collected activityOptions map
+    expect( fsMocks.writeFileSync ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath, contents ] = fsMocks.writeFileSync.mock.calls[0];
+    expect( writtenPath ).toMatch( /temp\/__activity_options\.js$/ );
+    expect( contents ).toContain( 'export default' );
+    expect( JSON.parse( contents.replace( /^export default\s*/, '' ).replace( /;\s*$/, '' ) ) ).toEqual( {
+      'A#Act1': { retry: { maximumAttempts: 3 } }
+    } );
+    expect( fsMocks.mkdirSync ).toHaveBeenCalled();
+  } );
+
+  it( 'loadActivities omits activity options when component has no options or no activityOptions', async () => {
+    const { loadActivities } = await import( './loader.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(
+      fsMocks.writeFileSync.mock.calls[0][1].replace( /^export default\s*/, '' ).replace( /;\s*$/, '' )
+    );
+    expect( written['A#NoOptions'] ).toBeUndefined();
+    expect( written['A#EmptyOptions'] ).toBeUndefined();
+  } );
+
+  it( 'loadWorkflows returns array of workflows with metadata', async () => {
+    const { loadWorkflows } = await import( './loader.js' );
+
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'Flow1', description: 'd' }, path: '/b/workflow.js' };
+    } );
+
+    const workflows = await loadWorkflows( '/root' );
+    expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', path: '/b/workflow.js' } ] );
+  } );
+
+  it( 'createWorkflowsEntryPoint writes index and returns its path', async () => {
+    const { createWorkflowsEntryPoint } = await import( './loader.js' );
+
+    const workflows = [ { name: 'W', path: '/abs/wf.js' } ];
+    const entry = createWorkflowsEntryPoint( workflows );
+
+    expect( fsMocks.writeFileSync ).toHaveBeenCalledTimes( 1 );
+    const [ writtenPath, contents ] = fsMocks.writeFileSync.mock.calls[0];
+    expect( entry ).toBe( writtenPath );
+    expect( contents ).toContain( 'export { default as W } from \'/abs/wf.js\';' );
+    expect( contents ).toContain( 'export { default as catalog }' );
+    expect( fsMocks.mkdirSync ).toHaveBeenCalledTimes( 1 );
+  } );
+
+  it( 'loadActivities uses folder-based matchers for steps/evaluators and shared', async () => {
+    const { loadActivities } = await import( './loader.js' );
+    // First call (workflow dir): no results
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+    // Second call (shared): no results
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+
+    const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
+    await loadActivities( '/root', workflows );
+
+    // First invocation should target the workflow directory with folder/file matchers
+    expect( importComponentsMock ).toHaveBeenCalledTimes( 2 );
+    const [ firstDir, firstMatchers ] = importComponentsMock.mock.calls[0];
+    expect( firstDir ).toBe( '/a' );
+    expect( Array.isArray( firstMatchers ) ).toBe( true );
+    // Should match folder-based steps and evaluators files
+    expect( firstMatchers.some( fn => fn( '/a/steps/foo.js' ) ) ).toBe( true );
+    expect( firstMatchers.some( fn => fn( '/a/evaluators/bar.js' ) ) ).toBe( true );
+    // And also direct file names
+    expect( firstMatchers.some( fn => fn( '/a/steps.js' ) ) ).toBe( true );
+    expect( firstMatchers.some( fn => fn( '/a/evaluators.js' ) ) ).toBe( true );
+
+    // Second invocation should target root with shared matchers
+    const [ secondDir, secondMatchers ] = importComponentsMock.mock.calls[1];
+    expect( secondDir ).toBe( '/root' );
+    expect( secondMatchers.some( fn => fn( '/root/shared/steps/baz.js' ) ) ).toBe( true );
+    expect( secondMatchers.some( fn => fn( '/root/shared/evaluators/qux.js' ) ) ).toBe( true );
+  } );
+
+  it( 'loadActivities includes nested workflow steps and shared evaluators', async () => {
+    const { loadActivities } = await import( './loader.js' );
+    // Workflow dir scan returns a nested step
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'ActNested' }, path: '/a/steps/foo.js' };
+    } );
+    // Shared scan returns a shared evaluator
+    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( 'loadWorkflows throws when workflow is under shared directory', async () => {
+    const { loadWorkflows } = await import( './loader.js' );
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { metadata: { name: 'Invalid' }, path: '/root/shared/workflow.js' };
+    } );
+    await expect( loadWorkflows( '/root' ) ).rejects.toThrow( 'Workflow directory can\'t be named \"shared\"' );
+  } );
+
+  it( 'collects workflow nested steps and evaluators across multiple subfolders', async () => {
+    const { loadActivities } = await import( './loader.js' );
+    // Workflow dir scan returns nested steps and evaluators
+    importComponentsMock.mockImplementationOnce( async function *() {
+      yield { fn: () => {}, metadata: { name: 'StepPrimary' }, path: '/a/steps/primary/foo.js' };
+      yield { fn: () => {}, metadata: { name: 'StepSecondary' }, path: '/a/steps/secondary/bar.js' };
+      yield { fn: () => {}, metadata: { name: 'EvalPrimary' }, path: '/a/evaluators/primary/baz.js' };
+      yield { fn: () => {}, metadata: { name: 'EvalSecondary' }, path: '/a/evaluators/secondary/qux.js' };
+    } );
+    // Shared scan returns nothing for this test
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+
+    const workflows = [ { name: 'A', path: '/a/workflow.js' } ];
+    const activities = await loadActivities( '/root', workflows );
+    expect( activities['A#StepPrimary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#StepSecondary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#EvalPrimary'] ).toBeTypeOf( 'function' );
+    expect( activities['A#EvalSecondary'] ).toBeTypeOf( 'function' );
+  } );
+
+  it( 'collects shared nested steps and evaluators across multiple subfolders', async () => {
+    const { loadActivities } = await import( './loader.js' );
+    // Workflow dir scan returns nothing for this test
+    importComponentsMock.mockImplementationOnce( async function *() {} );
+    // Shared scan returns nested steps and evaluators
+    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' );
+  } );
+
+  describe( 'loadHooks', () => {
+    it( 'resolves without importing when package.json does not exist', async () => {
+      fsMocks.existsSync.mockReturnValue( false );
+      const { loadHooks } = await import( './loader.js' );
+      await expect( loadHooks( '/root' ) ).resolves.toBeUndefined();
+      expect( fsMocks.existsSync ).toHaveBeenCalledWith( join( '/root', 'package.json' ) );
+    } );
+
+    it( 'imports hook files listed in 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: [ 'hook.js' ] }
+        } ) );
+        fs.writeFileSync( join( tmpDir, 'hook.js' ), 'globalThis.__loadHooksTestLoaded = true;' );
+
+        const { loadHooks } = await import( './loader.js' );
+        await loadHooks( tmpDir );
+        expect( globalThis.__loadHooksTestLoaded ).toBe( true );
+      } finally {
+        delete globalThis.__loadHooksTestLoaded;
+        fs.rmSync( tmpDir, { recursive: true, force: true } );
+      }
+    } );
+  } );
+} );

package/src/worker/loader_tools.js

@@ -0,0 +1,132 @@
+import { resolve, sep } from 'path';
+import { pathToFileURL } from 'url';
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { readdirSync } from 'fs';
+
+/**
+ * @typedef {object} CollectedFile
+ * @property {string} path - The file path
+ * @property {string} url - The resolved url of the file, ready to be imported
+ */
+/**
+ * @typedef {object} Component
+ * @property {Function} fn - The loaded component function
+ * @property {object} metadata - Associated metadata with the component
+ * @property {string} path - Associated metadata with the component
+ */
+
+/**
+ * Recursive traverse directories collection files with paths that match one of the given matches.
+ *
+ * @param {string} path - The path to scan
+ * @param {function[]} matchers - Boolean functions to match files to add to collection
+ * @returns {CollectedFile[]} An array containing the collected files
+ */
+const findByNameRecursively = ( parentPath, matchers, ignoreDirNames = [ 'vendor', 'node_modules' ] ) => {
+  const collection = [];
+  for ( const entry of readdirSync( parentPath, { withFileTypes: true } ) ) {
+    if ( ignoreDirNames.includes( entry.name ) ) {
+      continue;
+    }
+
+    const path = resolve( parentPath, entry.name );
+    if ( entry.isDirectory() ) {
+      collection.push( ...findByNameRecursively( path, matchers ) );
+    } else if ( matchers.some( m => m( path ) ) ) {
+      collection.push( { path, url: pathToFileURL( path ).href } );
+    }
+  }
+
+  return collection;
+};
+
+/**
+ * Scan a path for files testing each path against a matching function.
+ *
+ * For each file found, dynamic import it and for each exports on that file, yields it.
+ *
+ * @remarks
+ * - Only yields exports that have the METADATA_ACCESS_SYMBOL, as they are output components (steps, evaluators, etc).
+ *
+ * @generator
+ * @async
+ * @function importComponents
+ * @param {string} target - Place to look for files
+ * @param {function[]} matchers - Boolean functions to match files
+ * @yields {Component}
+ */
+export async function *importComponents( target, matchers ) {
+  for ( const { url, path } of findByNameRecursively( target, matchers ) ) {
+    const imported = await import( url );
+    for ( const fn of Object.values( imported ) ) {
+      const metadata = fn[METADATA_ACCESS_SYMBOL];
+      if ( !metadata ) {
+        continue;
+      }
+      yield { fn, metadata, path };
+    }
+  }
+};
+
+/**
+ * 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' )
+};

package/src/worker/loader_tools.spec.js

@@ -0,0 +1,156 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join, sep } from 'node:path';
+import { importComponents, staticMatchers } from './loader_tools.js';
+
+describe( '.importComponents', () => {
+  const TEMP_BASE = join( process.cwd(), 'sdk/core/temp_test_modules' );
+  afterEach( () => {
+    rmSync( TEMP_BASE, { recursive: true, force: true } );
+  } );
+  it( 'imports modules and yields metadata from exports tagged with METADATA_ACCESS_SYMBOL', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}` );
+    mkdirSync( root, { recursive: true } );
+    const file = join( root, 'meta.module.js' );
+    writeFileSync( file, [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export const StepA = () => {};',
+      'StepA[METADATA_ACCESS_SYMBOL] = { kind: "step", name: "a" };',
+      'export const FlowB = () => {};',
+      'FlowB[METADATA_ACCESS_SYMBOL] = { kind: "workflow", name: "b" };'
+    ].join( '\n' ) );
+
+    const collected = [];
+    for await ( const m of importComponents( root, [ v => v.endsWith( 'meta.module.js' ) ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 2 );
+    expect( collected.map( m => m.metadata.name ).sort() ).toEqual( [ 'a', 'b' ] );
+    expect( collected.map( m => m.metadata.kind ).sort() ).toEqual( [ 'step', 'workflow' ] );
+    for ( const m of collected ) {
+      expect( m.path ).toBe( file );
+      expect( typeof m.fn ).toBe( 'function' );
+    }
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'ignores exports without metadata symbol', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-nometa` );
+    mkdirSync( root, { recursive: true } );
+    const file = join( root, 'meta.module.js' );
+    writeFileSync( file, [
+      'export const Plain = () => {};',
+      'export const AlsoPlain = {}'
+    ].join( '\n' ) );
+
+    const collected = [];
+    for await ( const m of importComponents( root, [ v => v.endsWith( 'meta.module.js' ) ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 0 );
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'skips files inside ignored directories (node_modules, vendor)', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-ignoredirs` );
+    const okDir = join( root, 'ok' );
+    const nmDir = join( root, 'node_modules' );
+    const vendorDir = join( root, 'vendor' );
+    mkdirSync( okDir, { recursive: true } );
+    mkdirSync( nmDir, { recursive: true } );
+    mkdirSync( vendorDir, { recursive: true } );
+
+    const okFile = join( okDir, 'meta.module.js' );
+    const nmFile = join( nmDir, 'meta.module.js' );
+    const vendorFile = join( vendorDir, 'meta.module.js' );
+
+    const fileContents = [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export const C = () => {};',
+      'C[METADATA_ACCESS_SYMBOL] = { kind: "step", name: "c" };'
+    ].join( '\n' );
+    writeFileSync( okFile, fileContents );
+    writeFileSync( nmFile, fileContents );
+    writeFileSync( vendorFile, fileContents );
+
+    const collected = [];
+    for await ( const m of importComponents( root, [ v => v.endsWith( 'meta.module.js' ) ] ) ) {
+      collected.push( m );
+    }
+
+    expect( collected.length ).toBe( 1 );
+    expect( collected[0].path ).toBe( okFile );
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+
+  it( 'supports partial matching by folder name', async () => {
+    const root = join( process.cwd(), 'sdk/core/temp_test_modules', `meta-${Date.now()}-foldermatch` );
+    const okDir = join( root, 'features', 'ok' );
+    const otherDir = join( root, 'features', 'other' );
+    mkdirSync( okDir, { recursive: true } );
+    mkdirSync( otherDir, { recursive: true } );
+
+    const okFile = join( okDir, 'alpha.js' );
+    const otherFile = join( otherDir, 'beta.js' );
+    const src = [
+      'import { METADATA_ACCESS_SYMBOL } from "#consts";',
+      'export const X = () => {};',
+      'X[METADATA_ACCESS_SYMBOL] = { kind: "step", name: "x" };'
+    ].join( '\n' );
+    writeFileSync( okFile, src );
+    writeFileSync( otherFile, src );
+
+    // Match any JS under a folder named "ok"
+    const matcher = v => v.includes( `${join( 'features', 'ok' )}${sep}` );
+    const collected = [];
+    for await ( const m of importComponents( root, [ matcher ] ) ) {
+      collected.push( m );
+    }
+    expect( collected.length ).toBe( 1 );
+    expect( collected[0].path ).toBe( okFile );
+
+    rmSync( root, { recursive: true, force: true } );
+  } );
+} );
+
+describe( '.staticMatchers', () => {
+  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/log_hooks.js

@@ -0,0 +1,95 @@
+import { messageBus } from '#bus';
+import { createChildLogger } from '#logger';
+import { BusEventType, ComponentType, LifecycleEvent, WORKFLOW_CATALOG } from '#consts';
+
+const activityLog = createChildLogger( 'Activity' );
+const workflowLog = createChildLogger( 'Workflow' );
+
+/**
+ * Intercepts internal bus events for activity and workflow lifecycle and log them
+ */
+
+/*
+╔═════════════════╗
+║ Activity events ║
+╚═════════════════╝
+*/
+
+/**
+ * Returns true if activity event should be logged
+ */
+const shouldLogActivityEvent = ( { kind } ) => kind !== ComponentType.INTERNAL_STEP;
+
+messageBus.on( BusEventType.ACTIVITY_START, ( { id, name, kind, workflowId, workflowName } ) =>
+  shouldLogActivityEvent( { kind } ) && activityLog.info( `Started ${name} ${kind}`, {
+    event: LifecycleEvent.START,
+    activityId: id,
+    activityName: name,
+    activityKind: kind,
+    workflowId,
+    workflowName
+  } )
+);
+
+messageBus.on( BusEventType.ACTIVITY_END, ( { id, name, kind, workflowId, workflowName, duration } ) =>
+  shouldLogActivityEvent( { kind } ) && activityLog.info( `Ended ${name} ${kind}`, {
+    event: LifecycleEvent.END,
+    activityId: id,
+    activityName: name,
+    activityKind: kind,
+    workflowId,
+    workflowName,
+    durationMs: duration
+  } )
+);
+
+messageBus.on( BusEventType.ACTIVITY_ERROR, ( { id, name, kind, workflowId, workflowName, duration, error } ) =>
+  shouldLogActivityEvent( { kind } ) && activityLog.error( `Error ${name} ${kind}: ${error.constructor.name}`, {
+    event: LifecycleEvent.ERROR,
+    activityId: id,
+    activityName: name,
+    activityKind: kind,
+    workflowId,
+    workflowName,
+    durationMs: duration,
+    error: error.message
+  } )
+);
+
+/*
+╔═════════════════╗
+║ Workflow events ║
+╚═════════════════╝
+*/
+
+/**
+ * Returns true if activity event should be logged
+ */
+const shouldLogWorkflowEvent = ( { name } ) => name !== WORKFLOW_CATALOG;
+
+messageBus.on( BusEventType.WORKFLOW_START, ( { id, name } ) =>
+  shouldLogWorkflowEvent( { name } ) && workflowLog.info( `Started ${name} workflow`, {
+    event: LifecycleEvent.START,
+    workflowId: id,
+    workflowName: name
+  } )
+);
+
+messageBus.on( BusEventType.WORKFLOW_END, ( { id, name, duration } ) =>
+  shouldLogWorkflowEvent( { name } ) && workflowLog.info( `Ended ${name} workflow`, {
+    event: LifecycleEvent.END,
+    workflowId: id,
+    workflowName: name,
+    durationMs: duration
+  } )
+);
+
+messageBus.on( BusEventType.WORKFLOW_ERROR, ( { id, name, duration, error } ) =>
+  shouldLogWorkflowEvent( { name } ) && workflowLog.error( `Error ${name} workflow: ${error.constructor.name}`, {
+    event: LifecycleEvent.ERROR,
+    workflowId: id,
+    workflowName: name,
+    durationMs: duration,
+    error: error.message
+  } )
+);