ai-experiments 0.1.0 → 2.0.2

package/dist/types.d.ts

@@ -0,0 +1,198 @@
+/**
+ * Core types for AI experimentation
+ */
+/**
+ * A variant within an experiment
+ */
+export interface ExperimentVariant<TConfig = unknown> {
+    /** Unique identifier for the variant */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Variant configuration */
+    config: TConfig;
+    /** Weight for weighted random selection (default: 1) */
+    weight?: number;
+    /** Optional description */
+    description?: string;
+}
+/**
+ * Configuration for an experiment
+ */
+export interface ExperimentConfig<TConfig = unknown, TResult = unknown> {
+    /** Unique experiment identifier */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Experiment description */
+    description?: string;
+    /** List of variants to test */
+    variants: ExperimentVariant<TConfig>[];
+    /** Function to execute for each variant */
+    execute: (config: TConfig, context?: ExperimentContext) => Promise<TResult> | TResult;
+    /** Optional success metric function */
+    metric?: (result: TResult) => number | Promise<number>;
+    /** Metadata for the experiment */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Context passed to experiment execution
+ */
+export interface ExperimentContext {
+    /** Experiment ID */
+    experimentId: string;
+    /** Variant ID */
+    variantId: string;
+    /** Run ID (unique per execution) */
+    runId: string;
+    /** Timestamp when execution started */
+    startedAt: Date;
+    /** Additional context data */
+    data?: Record<string, unknown>;
+}
+/**
+ * Result of executing an experiment variant
+ */
+export interface ExperimentResult<TResult = unknown> {
+    /** Experiment ID */
+    experimentId: string;
+    /** Variant ID */
+    variantId: string;
+    /** Variant name */
+    variantName: string;
+    /** Run ID */
+    runId: string;
+    /** Execution result */
+    result: TResult;
+    /** Computed metric value (if metric function provided) */
+    metricValue?: number;
+    /** Execution duration in milliseconds */
+    duration: number;
+    /** Timestamp when execution started */
+    startedAt: Date;
+    /** Timestamp when execution completed */
+    completedAt: Date;
+    /** Error if execution failed */
+    error?: Error;
+    /** Success flag */
+    success: boolean;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Summary of experiment results across all variants
+ */
+export interface ExperimentSummary<TResult = unknown> {
+    /** Experiment ID */
+    experimentId: string;
+    /** Experiment name */
+    experimentName: string;
+    /** Results for each variant */
+    results: ExperimentResult<TResult>[];
+    /** Best performing variant (by metric) */
+    bestVariant?: {
+        variantId: string;
+        variantName: string;
+        metricValue: number;
+    };
+    /** Total execution duration */
+    totalDuration: number;
+    /** Number of successful runs */
+    successCount: number;
+    /** Number of failed runs */
+    failureCount: number;
+    /** Timestamp when experiment started */
+    startedAt: Date;
+    /** Timestamp when experiment completed */
+    completedAt: Date;
+}
+/**
+ * Options for running an experiment
+ */
+export interface RunExperimentOptions {
+    /** Run variants in parallel (default: true) */
+    parallel?: boolean;
+    /** Maximum concurrent executions (default: unlimited) */
+    maxConcurrency?: number;
+    /** Stop on first error (default: false) */
+    stopOnError?: boolean;
+    /** Custom context data */
+    context?: Record<string, unknown>;
+    /** Event callbacks */
+    onVariantStart?: (variantId: string, variantName: string) => void;
+    onVariantComplete?: (result: ExperimentResult) => void;
+    onVariantError?: (variantId: string, error: Error) => void;
+}
+/**
+ * Parameters for cartesian product generation
+ */
+export type CartesianParams = Record<string, unknown[]>;
+/**
+ * Result of cartesian product - array of parameter combinations
+ */
+export type CartesianResult<T extends CartesianParams> = Array<{
+    [K in keyof T]: T[K][number];
+}>;
+/**
+ * Decision options
+ */
+export interface DecideOptions<T> {
+    /** Options to choose from */
+    options: T[];
+    /** Scoring function for each option */
+    score: (option: T) => number | Promise<number>;
+    /** Context or prompt for decision making */
+    context?: string;
+    /** Whether to return all options sorted by score (default: false) */
+    returnAll?: boolean;
+}
+/**
+ * Result of a decision
+ */
+export interface DecisionResult<T> {
+    /** The selected option */
+    selected: T;
+    /** Score of the selected option */
+    score: number;
+    /** All options with their scores (if returnAll was true) */
+    allOptions?: Array<{
+        option: T;
+        score: number;
+    }>;
+}
+/**
+ * Tracking event types
+ */
+export type TrackingEventType = 'experiment.start' | 'experiment.complete' | 'variant.start' | 'variant.complete' | 'variant.error' | 'metric.computed' | 'decision.made';
+/**
+ * Tracking event
+ */
+export interface TrackingEvent {
+    /** Event type */
+    type: TrackingEventType;
+    /** Timestamp */
+    timestamp: Date;
+    /** Event data */
+    data: Record<string, unknown>;
+}
+/**
+ * Tracking backend interface
+ */
+export interface TrackingBackend {
+    /** Track an event */
+    track(event: TrackingEvent): void | Promise<void>;
+    /** Flush pending events */
+    flush?(): void | Promise<void>;
+}
+/**
+ * Options for tracking configuration
+ */
+export interface TrackingOptions {
+    /** Custom tracking backend */
+    backend?: TrackingBackend;
+    /** Whether tracking is enabled (default: true) */
+    enabled?: boolean;
+    /** Additional metadata to include with all events */
+    metadata?: Record<string, unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Core types for AI experimentation
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/examples.ts

@@ -0,0 +1,261 @@
+/**
+ * Usage examples for ai-experiments
+ *
+ * These examples demonstrate the core APIs and patterns.
+ */
+
+import {
+  Experiment,
+  cartesian,
+  decide,
+  track,
+  configureTracking,
+  createMemoryBackend,
+  type ExperimentConfig,
+} from './src/index.js'
+
+// ============================================================================
+// Example 1: Simple A/B Experiment
+// ============================================================================
+
+async function example1_simpleExperiment() {
+  console.log('\n=== Example 1: Simple A/B Experiment ===\n')
+
+  const results = await Experiment({
+    id: 'greeting-test',
+    name: 'Greeting Message Test',
+    description: 'Test different greeting messages',
+    variants: [
+      {
+        id: 'formal',
+        name: 'Formal Greeting',
+        config: { message: 'Good day, sir.' },
+      },
+      {
+        id: 'casual',
+        name: 'Casual Greeting',
+        config: { message: 'Hey there!' },
+      },
+      {
+        id: 'friendly',
+        name: 'Friendly Greeting',
+        config: { message: 'Hello friend!' },
+      },
+    ],
+    execute: async (config) => {
+      // Simulate some work
+      await new Promise((resolve) => setTimeout(resolve, 100))
+      return {
+        message: config.message,
+        wordCount: config.message.split(' ').length,
+        charCount: config.message.length,
+      }
+    },
+    metric: (result) => {
+      // Score based on message length (prefer shorter)
+      return 1 / result.charCount
+    },
+  })
+
+  console.log('Experiment Results:')
+  console.log('- Best Variant:', results.bestVariant)
+  console.log('- Success Rate:', `${results.successCount}/${results.results.length}`)
+  console.log('- Total Duration:', `${results.totalDuration}ms`)
+  console.log('\nAll Results:')
+  results.results.forEach((r) => {
+    console.log(
+      `  ${r.variantName}: metric=${r.metricValue?.toFixed(4)}, duration=${r.duration}ms`
+    )
+  })
+}
+
+// ============================================================================
+// Example 2: Parameter Grid with Cartesian Product
+// ============================================================================
+
+async function example2_parameterGrid() {
+  console.log('\n=== Example 2: Parameter Grid Experiment ===\n')
+
+  // Generate all combinations of parameters
+  const parameterGrid = cartesian({
+    temperature: [0.3, 0.7, 1.0],
+    maxTokens: [50, 100],
+    topP: [0.9, 1.0],
+  })
+
+  console.log(`Generated ${parameterGrid.length} parameter combinations:`)
+  parameterGrid.slice(0, 5).forEach((params, i) => {
+    console.log(`  ${i + 1}.`, params)
+  })
+  console.log('  ...')
+
+  // Create variants from parameter combinations
+  const variants = parameterGrid.map((params, i) => ({
+    id: `variant-${i}`,
+    name: `T=${params.temperature} max=${params.maxTokens} topP=${params.topP}`,
+    config: params,
+  }))
+
+  const results = await Experiment({
+    id: 'parameter-sweep',
+    name: 'Parameter Sweep Experiment',
+    variants,
+    execute: async (config) => {
+      // Simulate AI generation with different parameters
+      await new Promise((resolve) => setTimeout(resolve, 50))
+      const score = Math.random() * config.temperature + config.maxTokens / 1000
+      return { score, config }
+    },
+    metric: (result) => result.score,
+  })
+
+  console.log(`\nBest parameters: ${results.bestVariant?.variantName}`)
+  console.log(`Best score: ${results.bestVariant?.metricValue.toFixed(4)}`)
+}
+
+// ============================================================================
+// Example 3: Decision Making
+// ============================================================================
+
+async function example3_decisionMaking() {
+  console.log('\n=== Example 3: Decision Making ===\n')
+
+  // Simple decision with sync scoring
+  const result1 = await decide({
+    options: ['apple', 'banana', 'orange'],
+    score: (fruit) => {
+      const prices: Record<string, number> = { apple: 1.5, banana: 0.5, orange: 2.0 }
+      return 1 / prices[fruit] // Lower price = higher score
+    },
+    context: 'Choosing fruit based on value',
+  })
+
+  console.log('Decision 1 (best value):')
+  console.log(`  Selected: ${result1.selected}`)
+  console.log(`  Score: ${result1.score.toFixed(4)}`)
+
+  // Decision with all options returned
+  const result2 = await decide({
+    options: ['fast', 'accurate', 'balanced'],
+    score: async (approach) => {
+      const scores: Record<string, number> = { fast: 0.7, accurate: 0.85, balanced: 0.9 }
+      return scores[approach]
+    },
+    returnAll: true,
+  })
+
+  console.log('\nDecision 2 (with all options):')
+  console.log(`  Selected: ${result2.selected}`)
+  result2.allOptions?.forEach((opt) => {
+    console.log(`  - ${opt.option}: ${opt.score}`)
+  })
+}
+
+// ============================================================================
+// Example 4: Event Tracking
+// ============================================================================
+
+async function example4_eventTracking() {
+  console.log('\n=== Example 4: Event Tracking ===\n')
+
+  // Create a memory backend to collect events
+  const backend = createMemoryBackend()
+  configureTracking({ backend })
+
+  // Run a small experiment
+  await Experiment({
+    id: 'tracked-experiment',
+    name: 'Tracked Experiment',
+    variants: [
+      { id: 'v1', name: 'Variant 1', config: { value: 1 } },
+      { id: 'v2', name: 'Variant 2', config: { value: 2 } },
+    ],
+    execute: async (config) => ({ result: config.value * 2 }),
+    metric: (result) => result.result,
+  })
+
+  // Get all tracked events
+  const events = backend.getEvents()
+  console.log(`Tracked ${events.length} events:`)
+  events.forEach((event) => {
+    console.log(`  [${event.type}]`, JSON.stringify(event.data).slice(0, 80))
+  })
+
+  // Reset tracking to default
+  configureTracking({ enabled: true })
+}
+
+// ============================================================================
+// Example 5: Advanced - Sequential vs Parallel Execution
+// ============================================================================
+
+async function example5_executionModes() {
+  console.log('\n=== Example 5: Sequential vs Parallel Execution ===\n')
+
+  const variants = [
+    { id: 'v1', name: 'Variant 1', config: { delay: 100 } },
+    { id: 'v2', name: 'Variant 2', config: { delay: 150 } },
+    { id: 'v3', name: 'Variant 3', config: { delay: 200 } },
+  ]
+
+  const execute = async (config: { delay: number }) => {
+    await new Promise((resolve) => setTimeout(resolve, config.delay))
+    return { completed: true }
+  }
+
+  // Parallel execution (default)
+  const start1 = Date.now()
+  await Experiment({
+    id: 'parallel-test',
+    name: 'Parallel Execution',
+    variants,
+    execute,
+  })
+  const parallel_duration = Date.now() - start1
+
+  // Sequential execution
+  const start2 = Date.now()
+  await Experiment(
+    {
+      id: 'sequential-test',
+      name: 'Sequential Execution',
+      variants,
+      execute,
+    },
+    { parallel: false }
+  )
+  const sequential_duration = Date.now() - start2
+
+  console.log(`Parallel execution: ${parallel_duration}ms`)
+  console.log(`Sequential execution: ${sequential_duration}ms`)
+  console.log(
+    `Speedup: ${(sequential_duration / parallel_duration).toFixed(2)}x`
+  )
+}
+
+// ============================================================================
+// Run all examples
+// ============================================================================
+
+async function main() {
+  // Disable verbose tracking for examples
+  configureTracking({ enabled: false })
+
+  try {
+    await example1_simpleExperiment()
+    await example2_parameterGrid()
+    await example3_decisionMaking()
+    await example4_eventTracking()
+    await example5_executionModes()
+
+    console.log('\n✅ All examples completed successfully!\n')
+  } catch (error) {
+    console.error('\n❌ Error running examples:', error)
+    process.exit(1)
+  }
+}
+
+// Run if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main()
+}

package/package.json

@@ -1,50 +1,32 @@
 {
   "name": "ai-experiments",
-  "version": "0.1.0",
-  "description": "A minimalistic experiment runner for AI tasks",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "version": "2.0.2",
+  "description": "AI-powered experimentation primitives for testing and evaluating models",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs",
+      "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     }
   },
-  "files": [
-    "dist"
-  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "ai-functions": "2.0.2",
+    "rpc.do": "^0.1.0"
+  },
   "keywords": [
     "ai",
     "experiments",
-    "testing",
-    "vitest"
+    "primitives"
   ],
-  "dependencies": {
-    "vitest": "^1.1.0"
-  },
-  "devDependencies": {
-    "tsup": "^8.0.1",
-    "typescript": "^5.2.2",
-    "prettier": "^3.4.2",
-    "@types/node": "^20.17.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/drivly/primitives.org.ai.git"
-  },
-  "bugs": {
-    "url": "https://github.com/drivly/primitives.org.ai/issues"
-  },
-  "homepage": "https://primitives.org.ai",
-  "license": "MIT",
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "format": "prettier --write 'src/**/*.{ts,tsx,js,jsx}'"
-  }
-}
+  "license": "MIT"
+}