@orq-ai/evaluatorq 1.0.0-10

package/README.md

@@ -0,0 +1,239 @@
+# @orq-ai/evaluatorq
+
+An evaluation framework library that provides a flexible way to run parallel evaluations and optionally integrate with the Orq AI platform.
+
+## 🎯 Features
+
+- **Parallel Execution**: Run multiple evaluation jobs concurrently with progress tracking
+- **Flexible Data Sources**: Support for inline data, promises, and Orq platform datasets
+- **Type-safe**: Fully written in TypeScript
+- **Orq Platform Integration**: Seamlessly fetch and evaluate datasets from Orq AI (optional)
+
+## 📥 Installation
+
+```bash
+npm install @orq-ai/evaluatorq
+# or
+yarn add @orq-ai/evaluatorq
+# or
+bun add @orq-ai/evaluatorq
+```
+
+### Peer Dependencies
+
+If you want to use the Orq platform integration:
+
+```bash
+npm install @orq-ai/node
+```
+
+## 🚀 Quick Start
+
+### Basic Usage
+
+```typescript
+import { evaluatorq } from "@orq-ai/evaluatorq";
+
+await evaluatorq("text-analysis", {
+  data: [
+    { inputs: { text: "Hello world" } },
+    { inputs: { text: "Testing evaluation" } },
+  ],
+  jobs: [
+    async (data) => {
+      const text = data.inputs.text;
+      const analysis = {
+        length: text.length,
+        wordCount: text.split(" ").length,
+        uppercase: text.toUpperCase(),
+      };
+      
+      return {
+        name: "text-analyzer",
+        output: analysis,
+      };
+    },
+  ],
+  evaluators: [
+    {
+      name: "length-check",
+      scorer: async ({ output }) => {
+        return output.length > 10 ? 1 : 0;
+      },
+    },
+  ],
+});
+```
+
+### Using Orq Platform Datasets
+
+```typescript
+import { evaluatorq } from "@orq-ai/evaluatorq";
+
+// Requires ORQ_API_KEY environment variable
+await evaluatorq("dataset-evaluation", {
+  data: {
+    datasetId: "your-dataset-id", // From Orq platform
+  },
+  jobs: [
+    async (data) => {
+      // Process each data point from the dataset
+      return {
+        name: "processor",
+        output: processData(data),
+      };
+    },
+  ],
+  evaluators: [
+    {
+      name: "accuracy",
+      scorer: async ({ data, output }) => {
+        // Compare output with expected results
+        return calculateScore(output, data.expectedOutput);
+      },
+    },
+  ],
+});
+```
+
+### Advanced Features
+
+#### Multiple Jobs
+
+Run multiple jobs in parallel for each data point:
+
+```typescript
+await evaluatorq("multi-job-eval", {
+  data: [...],
+  jobs: [
+    async (data) => ({
+      name: "preprocessor",
+      output: preprocess(data),
+    }),
+    async (data) => ({
+      name: "analyzer",
+      output: analyze(data),
+    }),
+    async (data) => ({
+      name: "transformer",
+      output: transform(data),
+    }),
+  ],
+  evaluators: [...],
+});
+```
+
+#### Custom Error Handling
+
+```typescript
+await evaluatorq("error-handling", {
+  data: [...],
+  jobs: [
+    async (data) => {
+      try {
+        const result = await riskyOperation(data);
+        return { name: "risky-job", output: result };
+      } catch (error) {
+        // Errors are captured and included in the evaluation results
+        throw new Error(`Failed to process: ${error.message}`);
+      }
+    },
+  ],
+  evaluators: [...],
+});
+```
+
+#### Async Data Sources
+
+```typescript
+// Create an array of promises for async data
+const dataPromises = Array.from({ length: 1000 }, (_, i) => 
+  Promise.resolve({ inputs: { value: i } })
+);
+
+await evaluatorq("async-eval", {
+  data: dataPromises,
+  jobs: [...],
+  evaluators: [...],
+});
+```
+
+## 🔧 Configuration
+
+### Environment Variables
+
+- `ORQ_API_KEY`: API key for Orq platform integration (required for dataset access)
+
+## 📚 API Reference
+
+### `evaluatorq(name, options)`
+
+Main function to run evaluations.
+
+#### Parameters:
+
+- `name`: String identifier for the evaluation run
+- `options`: Configuration object with:
+  - `data`: Array of data points, async iterable, or Orq dataset config
+  - `jobs`: Array of job functions to run on each data point
+  - `evaluators`: Array of evaluator configurations
+
+#### Returns:
+
+Promise that resolves when evaluation is complete.
+
+### Types
+
+```typescript
+type Output = string | number | boolean | Record<string, unknown> | null;
+
+interface DataPoint {
+  inputs: Record<string, unknown>;
+  expectedOutput?: Output;
+}
+
+interface JobResult {
+  jobName: string;
+  output: Output;
+  error?: Error;
+  evaluatorScores?: EvaluatorScore[];
+}
+
+interface EvaluatorScore {
+  evaluatorName: string;
+  score: number | boolean | string;
+  error?: Error;
+}
+
+type Job = (
+  data: DataPoint,
+  row: number,
+) => Promise<{
+  name: string;
+  output: Output;
+}>;
+
+type ScorerParameter = {
+  data: DataPoint;
+  output: Output;
+};
+
+type Scorer =
+  | ((params: ScorerParameter) => Promise<string>)
+  | ((params: ScorerParameter) => Promise<number>)
+  | ((params: ScorerParameter) => Promise<boolean>);
+```
+
+## 🛠️ Development
+
+```bash
+# Build the package
+bunx nx build evaluatorq
+
+# Run type checking
+bunx nx typecheck evaluatorq
+```
+
+## 📄 License
+
+This is free and unencumbered software released into the public domain. See [UNLICENSE](https://unlicense.org) for details.

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./lib/evaluatorq.js";
+export { displayResultsTableEffect } from "./lib/table-display.js";
+export * from "./lib/types.js";
+export * from "./lib/visualizer/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./lib/evaluatorq.js";
+export { displayResultsTableEffect } from "./lib/table-display.js";
+export * from "./lib/types.js";
+export * from "./lib/visualizer/index.js";

package/dist/lib/effects.d.ts

@@ -0,0 +1,12 @@
+import { Effect } from "effect";
+import { ProgressService } from "./progress.js";
+import type { DataPoint, DataPointResult, Job, JobResult, Scorer } from "./types.js";
+export declare function processDataPointEffect(dataPromise: Promise<DataPoint>, rowIndex: number, jobs: Job[], evaluators: {
+    name: string;
+    scorer: Scorer;
+}[], parallelism: number): Effect.Effect<DataPointResult[], Error, ProgressService>;
+export declare function processJobEffect(job: Job, dataPoint: DataPoint, rowIndex: number, evaluators: {
+    name: string;
+    scorer: Scorer;
+}[]): Effect.Effect<JobResult, Error, ProgressService>;
+//# sourceMappingURL=effects.d.ts.map

package/dist/lib/effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects.d.ts","sourceRoot":"","sources":["../../src/lib/effects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EACV,SAAS,EACT,eAAe,EACf,GAAG,EACH,SAAS,EACT,MAAM,EACP,MAAM,YAAY,CAAC;AAEpB,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,OAAO,CAAC,SAAS,CAAC,EAC/B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,GAAG,EAAE,EACX,UAAU,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,EAC9C,WAAW,EAAE,MAAM,GAClB,MAAM,CAAC,MAAM,CAAC,eAAe,EAAE,EAAE,KAAK,EAAE,eAAe,CAAC,CA4C1D;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,GAC7C,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,KAAK,EAAE,eAAe,CAAC,CAyGlD"}

package/dist/lib/effects.js

@@ -0,0 +1,89 @@
+import { Effect, pipe } from "effect";
+import { ProgressService } from "./progress.js";
+export function processDataPointEffect(dataPromise, rowIndex, jobs, evaluators, parallelism) {
+    return pipe(Effect.tryPromise({
+        try: () => dataPromise,
+        catch: (error) => error,
+    }), Effect.flatMap((dataPoint) => Effect.gen(function* (_) {
+        const progress = yield* _(ProgressService);
+        // Update progress for this data point
+        yield* _(progress.updateProgress({
+            currentDataPoint: rowIndex + 1,
+            phase: "processing",
+        }));
+        // Process jobs
+        const jobResults = yield* _(Effect.forEach(jobs, (job) => processJobEffect(job, dataPoint, rowIndex, evaluators), { concurrency: parallelism }));
+        return [
+            {
+                dataPoint,
+                jobResults,
+            },
+        ];
+    })), Effect.catchAll((error) => Effect.succeed([
+        {
+            dataPoint: { inputs: {} }, // Placeholder since we couldn't get the actual data
+            error,
+        },
+    ])));
+}
+export function processJobEffect(job, dataPoint, rowIndex, evaluators) {
+    return Effect.gen(function* (_) {
+        const progress = yield* _(ProgressService);
+        // Update progress with current job
+        const jobResult = yield* _(pipe(Effect.Do, Effect.bind("jobName", () => Effect.sync(() => {
+            // Try to get job name from a test run or use a placeholder
+            return "job";
+        })), Effect.tap(({ jobName }) => progress.updateProgress({
+            currentJob: jobName,
+            phase: "processing",
+        })), Effect.bind("result", () => Effect.tryPromise({
+            try: () => job(dataPoint, rowIndex),
+            catch: (error) => error,
+        })), Effect.tap(({ result }) => progress.updateProgress({
+            currentJob: result.name,
+        })), Effect.map(({ result }) => result)));
+        // Process evaluators if any
+        if (evaluators.length > 0) {
+            // Update phase to evaluating
+            yield* _(progress.updateProgress({ phase: "evaluating" }));
+            const evaluatorScores = yield* _(Effect.forEach(evaluators, (evaluator) => Effect.gen(function* (_) {
+                // Update current evaluator
+                yield* _(progress.updateProgress({
+                    currentEvaluator: evaluator.name,
+                }));
+                const score = yield* _(pipe(Effect.tryPromise({
+                    try: async () => {
+                        const result = await evaluator.scorer({
+                            data: dataPoint,
+                            output: jobResult.output,
+                        });
+                        return result;
+                    },
+                    catch: (error) => error,
+                }), Effect.map((score) => ({
+                    evaluatorName: evaluator.name,
+                    score: score,
+                })), Effect.catchAll((error) => Effect.succeed({
+                    evaluatorName: evaluator.name,
+                    score: "",
+                    error: error,
+                }))));
+                return score;
+            }), { concurrency: "unbounded" }));
+            return {
+                jobName: jobResult.name,
+                output: jobResult.output,
+                evaluatorScores,
+            };
+        }
+        return {
+            jobName: jobResult.name,
+            output: jobResult.output,
+            evaluatorScores: [],
+        };
+    }).pipe(Effect.catchAll((error) => Effect.succeed({
+        jobName: "Unknown", // We don't know the job name if it threw before returning
+        output: null,
+        error,
+    })));
+}

package/dist/lib/evaluatorq.d.ts

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import type { EvaluatorParams, EvaluatorqResult } from "./types.js";
+/**
+ * @param _name - The name of the evaluation run.
+ * @param params - The parameters for the evaluation run.
+ * @returns The results of the evaluation run.
+ */
+export declare function evaluatorq(_name: string, params: EvaluatorParams): Promise<EvaluatorqResult>;
+export declare const evaluatorqEffect: (_name: string, params: EvaluatorParams) => Effect.Effect<EvaluatorqResult, Error, never>;
+export declare const evaluatorqWithTableEffect: (name: string, params: EvaluatorParams) => Effect.Effect<EvaluatorqResult, Error, never>;
+//# sourceMappingURL=evaluatorq.d.ts.map

package/dist/lib/evaluatorq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluatorq.d.ts","sourceRoot":"","sources":["../../src/lib/evaluatorq.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAQ,MAAM,QAAQ,CAAC;AAWtC,OAAO,KAAK,EAEV,eAAe,EACf,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AA+CpB;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAsE3B;AAGD,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,EACb,QAAQ,eAAe,KACtB,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE,KAAK,EAAE,KAAK,CAuD9C,CAAC;AAsDF,eAAO,MAAM,yBAAyB,GACpC,MAAM,MAAM,EACZ,QAAQ,eAAe,KACtB,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE,KAAK,EAAE,KAAK,CAI5C,CAAC"}

package/dist/lib/evaluatorq.js

@@ -0,0 +1,139 @@
+import { Effect, pipe } from "effect";
+import { processDataPointEffect } from "./effects.js";
+import { ProgressService, ProgressServiceLive, withProgress, } from "./progress.js";
+import { displayResultsTableEffect } from "./table-display.js";
+async function setupOrqClient(apiKey) {
+    try {
+        const client = await import("@orq-ai/node");
+        return new client.Orq({ apiKey });
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "MODULE_NOT_FOUND" ||
+            err.code === "ERR_MODULE_NOT_FOUND" ||
+            err.message?.includes("Cannot find module")) {
+            throw new Error("The @orq-ai/node package is not installed. To use dataset features, please install it:\n" +
+                "  npm install @orq-ai/node\n" +
+                "  # or\n" +
+                "  yarn add @orq-ai/node\n" +
+                "  # or\n" +
+                "  bun add @orq-ai/node");
+        }
+        throw new Error(`Failed to setup ORQ client: ${err.message || err}`);
+    }
+}
+async function fetchDatasetAsDataPoints(orqClient, datasetId) {
+    try {
+        const response = await orqClient.datasets.listDatapoints({ datasetId });
+        return response.data.map((datapoint) => Promise.resolve({
+            inputs: datapoint.inputs || {},
+            expectedOutput: datapoint.expectedOutput,
+        }));
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch dataset ${datasetId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * @param _name - The name of the evaluation run.
+ * @param params - The parameters for the evaluation run.
+ * @returns The results of the evaluation run.
+ */
+export async function evaluatorq(_name, params) {
+    const { data, evaluators = [], jobs, parallelism = 1, print = true } = params;
+    let orqClient;
+    const orqApiKey = process.env.ORQ_API_KEY;
+    if (orqApiKey) {
+        orqClient = await setupOrqClient(orqApiKey);
+    }
+    let dataPromises;
+    // Handle datasetId case
+    if ("datasetId" in data) {
+        if (!orqApiKey || !orqClient) {
+            throw new Error("ORQ_API_KEY environment variable must be set to fetch datapoints from Orq platform.");
+        }
+        dataPromises = await fetchDatasetAsDataPoints(orqClient, data.datasetId);
+    }
+    else {
+        dataPromises = data;
+    }
+    // Create Effect for processing all data points
+    const program = pipe(Effect.gen(function* (_) {
+        const progress = yield* _(ProgressService);
+        // Initialize progress
+        yield* _(progress.updateProgress({
+            totalDataPoints: dataPromises.length,
+            currentDataPoint: 0,
+            phase: "initializing",
+        }));
+        // Process data points
+        const results = yield* _(Effect.forEach(dataPromises.map((dataPromise, index) => ({ dataPromise, index })), ({ dataPromise, index }) => processDataPointEffect(dataPromise instanceof Promise
+            ? dataPromise
+            : Promise.resolve(dataPromise), index, jobs, evaluators, parallelism), { concurrency: parallelism }));
+        return results.flat();
+    }), 
+    // Conditionally add table display
+    print
+        ? Effect.tap((results) => displayResultsTableEffect(results))
+        : Effect.tap(() => Effect.void), 
+    // Provide the progress service
+    Effect.provide(ProgressServiceLive), 
+    // Wrap with progress tracking
+    (effect) => withProgress(effect, print));
+    // Run the Effect and convert back to Promise
+    return Effect.runPromise(program);
+}
+// Create an Effect that runs evaluation and optionally displays results
+export const evaluatorqEffect = (_name, params) => {
+    const { data, evaluators = [], jobs, parallelism = 1, print = true } = params;
+    // Handle datasetId case
+    if ("datasetId" in data) {
+        return Effect.gen(function* (_) {
+            const apiKey = process.env.ORQ_API_KEY;
+            if (!apiKey) {
+                return yield* _(Effect.fail(new Error("ORQ_API_KEY environment variable must be set to fetch datasets from Orq platform.")));
+            }
+            const orqClient = yield* _(Effect.tryPromise({
+                try: () => setupOrqClient(apiKey),
+                catch: (error) => new Error(`Failed to setup Orq client: ${error instanceof Error ? error.message : String(error)}`),
+            }));
+            if (!orqClient) {
+                return yield* _(Effect.fail(new Error("Failed to setup Orq client")));
+            }
+            const dataPromises = yield* _(Effect.tryPromise({
+                try: () => fetchDatasetAsDataPoints(orqClient, data.datasetId),
+                catch: (error) => error instanceof Error
+                    ? error
+                    : new Error(`Failed to fetch dataset: ${String(error)}`),
+            }));
+            return yield* _(runEvaluationEffect(dataPromises, evaluators, jobs, parallelism, print));
+        });
+    }
+    const dataPromises = data;
+    return runEvaluationEffect(dataPromises, evaluators, jobs, parallelism, print);
+};
+// Extract common evaluation logic
+const runEvaluationEffect = (dataPromises, evaluators = [], jobs, parallelism, print) => pipe(Effect.gen(function* (_) {
+    const progress = yield* _(ProgressService);
+    // Initialize progress
+    yield* _(progress.updateProgress({
+        totalDataPoints: dataPromises.length,
+        currentDataPoint: 0,
+        phase: "initializing",
+    }));
+    // Process data points
+    const results = yield* _(Effect.forEach(dataPromises.map((dataPromise, index) => ({ dataPromise, index })), ({ dataPromise, index }) => processDataPointEffect(dataPromise instanceof Promise
+        ? dataPromise
+        : Promise.resolve(dataPromise), index, jobs, evaluators, parallelism), { concurrency: parallelism }));
+    return results.flat();
+}), 
+// Conditionally add table display
+print
+    ? Effect.tap((results) => displayResultsTableEffect(results))
+    : Effect.tap(() => Effect.void), 
+// Provide the progress service
+Effect.provide(ProgressServiceLive), 
+// Wrap with progress tracking
+(effect) => withProgress(effect, print));
+// Composable evaluatorq with display
+export const evaluatorqWithTableEffect = (name, params) => pipe(evaluatorqEffect(name, params), Effect.tap((results) => displayResultsTableEffect(results)));

package/dist/lib/progress.d.ts

@@ -0,0 +1,18 @@
+import { Context, Effect, Layer } from "effect";
+export interface ProgressState {
+    totalDataPoints: number;
+    currentDataPoint: number;
+    currentJob?: string;
+    currentEvaluator?: string;
+    phase: "initializing" | "processing" | "evaluating" | "completed";
+}
+export interface ProgressService {
+    readonly updateProgress: (update: Partial<ProgressState>) => Effect.Effect<void>;
+    readonly startSpinner: () => Effect.Effect<void>;
+    readonly stopSpinner: () => Effect.Effect<void>;
+    readonly showMessage: (message: string) => Effect.Effect<void>;
+}
+export declare const ProgressService: Context.Tag<ProgressService, ProgressService>;
+export declare const ProgressServiceLive: Layer.Layer<ProgressService, never, never>;
+export declare const withProgress: <R, E, A>(effect: Effect.Effect<A, E, R>, showProgress?: boolean) => Effect.Effect<A, E, R>;
+//# sourceMappingURL=progress.d.ts.map

package/dist/lib/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["../../src/lib/progress.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAIhD,MAAM,WAAW,aAAa;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,EAAE,cAAc,GAAG,YAAY,GAAG,YAAY,GAAG,WAAW,CAAC;CACnE;AAGD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,cAAc,EAAE,CACvB,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,KAC3B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjD,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAChD,QAAQ,CAAC,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;CAChE;AAGD,eAAO,MAAM,eAAe,+CAC4B,CAAC;AA2GzD,eAAO,MAAM,mBAAmB,4CAG/B,CAAC;AAGF,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAClC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC9B,eAAc,OAAc,KAC3B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CA4BvB,CAAC"}

package/dist/lib/progress.js

@@ -0,0 +1,114 @@
+import chalk from "chalk";
+import { Context, Effect, Layer } from "effect";
+import ora from "ora";
+// Context tag for the progress service
+export const ProgressService = Context.GenericTag("ProgressService");
+// Spinner instance
+let spinner = null;
+// Create the progress service implementation
+const makeProgressService = () => {
+    let state = {
+        totalDataPoints: 0,
+        currentDataPoint: 0,
+        phase: "initializing",
+    };
+    const formatProgressText = () => {
+        const percentage = state.totalDataPoints > 0
+            ? Math.round((state.currentDataPoint / state.totalDataPoints) * 100)
+            : 0;
+        let text = "";
+        switch (state.phase) {
+            case "initializing":
+                text = chalk.cyan("Initializing evaluation...");
+                break;
+            case "processing":
+                text = chalk.cyan(`Processing data point ${state.currentDataPoint}/${state.totalDataPoints} (${percentage}%)`);
+                if (state.currentJob) {
+                    text += chalk.gray(` - Running job: ${chalk.white(state.currentJob)}`);
+                }
+                break;
+            case "evaluating":
+                text = chalk.cyan(`Evaluating results ${state.currentDataPoint}/${state.totalDataPoints} (${percentage}%)`);
+                if (state.currentEvaluator) {
+                    text += chalk.gray(` - Running evaluator: ${chalk.white(state.currentEvaluator)}`);
+                }
+                break;
+            case "completed":
+                text = chalk.green("✓ Evaluation completed");
+                break;
+        }
+        return text;
+    };
+    return {
+        updateProgress: (update) => Effect.sync(() => {
+            state = { ...state, ...update };
+            if (spinner) {
+                spinner.text = formatProgressText();
+            }
+        }),
+        startSpinner: () => Effect.sync(() => {
+            if (!spinner) {
+                // Reserve space first by printing empty lines
+                process.stdout.write("\n\n\n");
+                // Move cursor back up to where we want the spinner
+                process.stdout.write("\x1b[3A");
+                spinner = ora({
+                    text: formatProgressText(),
+                    spinner: "dots",
+                    color: "cyan",
+                });
+                spinner.start();
+            }
+        }),
+        stopSpinner: () => Effect.sync(() => {
+            if (spinner) {
+                if (state.phase === "completed") {
+                    spinner.succeed(chalk.green("✓ Evaluation completed successfully"));
+                    // Just one newline since table display adds its own
+                    process.stdout.write("\n");
+                }
+                else {
+                    spinner.stop();
+                    // Just one newline since table display adds its own
+                    process.stdout.write("\n");
+                }
+                spinner = null;
+            }
+        }),
+        showMessage: (message) => Effect.sync(() => {
+            if (spinner) {
+                spinner.info(message);
+            }
+            else {
+                console.log(message);
+            }
+        }),
+    };
+};
+// Create a layer for the progress service
+export const ProgressServiceLive = Layer.succeed(ProgressService, makeProgressService());
+// Helper function to run with progress tracking
+export const withProgress = (effect, showProgress = true) => {
+    if (!showProgress) {
+        return effect;
+    }
+    return Effect.gen(function* (_) {
+        const progress = yield* _(ProgressService);
+        // Start spinner
+        yield* _(progress.startSpinner());
+        try {
+            // Run the effect
+            const result = yield* _(effect);
+            // Update to completed state
+            yield* _(progress.updateProgress({ phase: "completed" }));
+            // Stop spinner with success
+            yield* _(progress.stopSpinner());
+            return result;
+        }
+        catch (error) {
+            // Stop spinner on error
+            yield* _(progress.stopSpinner());
+            throw error;
+        }
+    }).pipe(Effect.provide(ProgressServiceLive));
+};

package/dist/lib/table-display.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+import type { EvaluatorqResult } from "./types.js";
+export declare const displayResultsTableEffect: (results: EvaluatorqResult) => Effect.Effect<void, never, never>;
+//# sourceMappingURL=table-display.d.ts.map

package/dist/lib/table-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-display.d.ts","sourceRoot":"","sources":["../../src/lib/table-display.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA0TnD,eAAO,MAAM,yBAAyB,GACpC,SAAS,gBAAgB,KACxB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CA+B/B,CAAC"}