ai-experiments 2.0.2 → 2.1.3

package/.turbo/turbo-build.log

@@ -1,5 +1,4 @@
-
-
-> ai-experiments@2.0.1 build /Users/nathanclevenger/projects/primitives.org.ai/packages/ai-experiments
-> tsc
-
+
+> ai-experiments@2.1.3 build /Users/nathanclevenger/projects/primitives.org.ai/packages/ai-experiments
+> tsc
+

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # ai-experiments
 
+## 2.1.3
+
+### Patch Changes
+
+- Updated dependencies
+  - ai-functions@2.1.3
+
+## 2.1.1
+
+### Patch Changes
+
+- Updated dependencies [6beb531]
+  - ai-functions@2.1.1
+
+## 2.0.3
+
+### Patch Changes
+
+- Updated dependencies
+  - rpc.do@0.2.0
+  - ai-functions@2.0.3
+
 ## 2.0.2
 
 ### Patch Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 .org.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chdb-storage.d.ts

@@ -0,0 +1,135 @@
+/**
+ * ClickHouse storage backend for AI experiments using chdb (embedded ClickHouse)
+ *
+ * Design: Single flat table where experiment events are the atomic unit.
+ * Cartesian product results, variant comparisons, and winner analysis
+ * are all derived via aggregation queries.
+ *
+ * This maximizes compression and enables fast analytical queries across
+ * thousands of experiment runs.
+ */
+import type { TrackingBackend, TrackingEvent, ExperimentResult } from './types.js';
+export interface ChdbStorageOptions {
+    /** Path to store the chdb database (default: ./.experiments-chdb) */
+    dataPath?: string;
+    /** Whether to create tables on init (default: true) */
+    autoInit?: boolean;
+}
+export declare class ChdbStorage implements TrackingBackend {
+    private options;
+    private session;
+    private initialized;
+    private eventCounter;
+    constructor(options?: ChdbStorageOptions);
+    private init;
+    private escapeString;
+    private toJson;
+    private parseJson;
+    private nextEventId;
+    track(event: TrackingEvent): Promise<void>;
+    flush(): Promise<void>;
+    storeResult(result: ExperimentResult): Promise<void>;
+    storeResults(results: ExperimentResult[]): Promise<void>;
+    /**
+     * Get all experiments
+     */
+    getExperiments(): Promise<Array<{
+        experimentId: string;
+        experimentName: string;
+        variantCount: number;
+        runCount: number;
+        firstRun: string;
+        lastRun: string;
+    }>>;
+    /**
+     * Get variant performance for an experiment
+     */
+    getVariantStats(experimentId: string): Promise<Array<{
+        variantId: string;
+        variantName: string;
+        runCount: number;
+        successCount: number;
+        successRate: number;
+        avgDuration: number;
+        avgMetric: number;
+        minMetric: number;
+        maxMetric: number;
+    }>>;
+    /**
+     * Get the best performing variant for an experiment
+     */
+    getBestVariant(experimentId: string, options?: {
+        metric?: 'avgMetric' | 'successRate' | 'avgDuration';
+        minimumRuns?: number;
+    }): Promise<{
+        variantId: string;
+        variantName: string;
+        metricValue: number;
+        runCount: number;
+    } | null>;
+    /**
+     * Get cartesian product analysis - performance by dimension values
+     */
+    getCartesianAnalysis(experimentId: string, dimension: string): Promise<Array<{
+        dimensionValue: string;
+        runCount: number;
+        avgMetric: number;
+        successRate: number;
+    }>>;
+    /**
+     * Get multi-dimensional cartesian analysis
+     */
+    getCartesianGrid(experimentId: string, dimensions: string[]): Promise<Array<{
+        dimensions: Record<string, string>;
+        runCount: number;
+        avgMetric: number;
+        successRate: number;
+    }>>;
+    /**
+     * Get time series of experiment metrics
+     */
+    getTimeSeries(experimentId: string, options?: {
+        interval?: 'hour' | 'day' | 'week';
+        variantId?: string;
+    }): Promise<Array<{
+        period: string;
+        runCount: number;
+        avgMetric: number;
+        successRate: number;
+    }>>;
+    /**
+     * Get raw events for an experiment
+     */
+    getEvents(experimentId: string, options?: {
+        eventType?: string;
+        variantId?: string;
+        limit?: number;
+    }): Promise<TrackingEvent[]>;
+    /**
+     * Raw SQL query access for custom analytics
+     */
+    query(sql: string, format?: string): string;
+    /**
+     * Close the storage (cleanup)
+     */
+    close(): void;
+}
+/**
+ * Create a chdb storage backend for experiments
+ *
+ * @example
+ * ```ts
+ * import { configureTracking } from 'ai-experiments'
+ * import { createChdbBackend } from 'ai-experiments/storage'
+ *
+ * const storage = createChdbBackend({ dataPath: './.my-experiments' })
+ *
+ * configureTracking({ backend: storage })
+ *
+ * // Later: analyze results
+ * const best = await storage.getBestVariant('my-experiment')
+ * console.log(`Best variant: ${best.variantName} (${best.metricValue})`)
+ * ```
+ */
+export declare function createChdbBackend(options?: ChdbStorageOptions): ChdbStorage;
+//# sourceMappingURL=chdb-storage.d.ts.map

package/dist/chdb-storage.d.ts.map

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

package/dist/chdb-storage.js

@@ -0,0 +1,468 @@
+/**
+ * ClickHouse storage backend for AI experiments using chdb (embedded ClickHouse)
+ *
+ * Design: Single flat table where experiment events are the atomic unit.
+ * Cartesian product results, variant comparisons, and winner analysis
+ * are all derived via aggregation queries.
+ *
+ * This maximizes compression and enables fast analytical queries across
+ * thousands of experiment runs.
+ */
+import { Session } from 'chdb';
+const CREATE_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS experiments (
+    -- Event identity
+    eventId String,
+    eventType LowCardinality(String),
+    timestamp DateTime64(3),
+
+    -- Experiment context
+    experimentId String,
+    experimentName String DEFAULT '',
+
+    -- Variant context
+    variantId String DEFAULT '',
+    variantName String DEFAULT '',
+
+    -- Cartesian product dimensions (stored as JSON for flexibility)
+    dimensions String DEFAULT '{}',
+
+    -- Execution data
+    runId String DEFAULT '',
+    success UInt8 DEFAULT 1,
+    durationMs UInt32 DEFAULT 0,
+
+    -- Result data
+    result String DEFAULT '{}',
+    metricName LowCardinality(String) DEFAULT '',
+    metricValue Float64 DEFAULT 0,
+
+    -- Error tracking
+    errorMessage String DEFAULT '',
+    errorStack String DEFAULT '',
+
+    -- Metadata
+    metadata String DEFAULT '{}'
+)
+ENGINE = MergeTree()
+ORDER BY (experimentId, variantId, timestamp, eventId)
+SETTINGS index_granularity = 8192
+`;
+export class ChdbStorage {
+    options;
+    session;
+    initialized = false;
+    eventCounter = 0;
+    constructor(options = {}) {
+        this.options = options;
+        this.session = new Session(options.dataPath ?? './.experiments-chdb');
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        if (this.options.autoInit !== false) {
+            this.session.query(CREATE_TABLE_SQL);
+        }
+        this.initialized = true;
+    }
+    escapeString(s) {
+        return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+    }
+    toJson(value) {
+        return JSON.stringify(value ?? {});
+    }
+    parseJson(value) {
+        try {
+            return JSON.parse(value || '{}');
+        }
+        catch {
+            return {};
+        }
+    }
+    nextEventId() {
+        return `evt-${Date.now()}-${++this.eventCounter}`;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // TrackingBackend Implementation
+    // ─────────────────────────────────────────────────────────────────────────────
+    async track(event) {
+        await this.init();
+        const eventId = this.nextEventId();
+        const timestamp = event.timestamp.toISOString();
+        const data = event.data;
+        // Extract standard fields from event data
+        const experimentId = String(data.experimentId ?? '');
+        const experimentName = String(data.experimentName ?? '');
+        const variantId = String(data.variantId ?? '');
+        const variantName = String(data.variantName ?? '');
+        const runId = String(data.runId ?? '');
+        const success = data.success !== false ? 1 : 0;
+        const durationMs = Number(data.duration ?? data.durationMs ?? 0);
+        const metricName = String(data.metricName ?? '');
+        const metricValue = Number(data.metricValue ?? 0);
+        const errorMessage = data.error instanceof Error ? data.error.message : String(data.errorMessage ?? '');
+        const errorStack = data.error instanceof Error ? (data.error.stack ?? '') : '';
+        // Extract dimensions (for cartesian product tracking)
+        const dimensions = data.dimensions ?? data.config ?? {};
+        const result = data.result ?? {};
+        const metadata = data.metadata ?? {};
+        this.session.query(`
+      INSERT INTO experiments (
+        eventId, eventType, timestamp,
+        experimentId, experimentName,
+        variantId, variantName,
+        dimensions, runId, success, durationMs,
+        result, metricName, metricValue,
+        errorMessage, errorStack, metadata
+      ) VALUES (
+        '${eventId}', '${event.type}', '${timestamp}',
+        '${this.escapeString(experimentId)}', '${this.escapeString(experimentName)}',
+        '${this.escapeString(variantId)}', '${this.escapeString(variantName)}',
+        '${this.escapeString(this.toJson(dimensions))}',
+        '${this.escapeString(runId)}', ${success}, ${durationMs},
+        '${this.escapeString(this.toJson(result))}',
+        '${this.escapeString(metricName)}', ${metricValue},
+        '${this.escapeString(errorMessage)}', '${this.escapeString(errorStack)}',
+        '${this.escapeString(this.toJson(metadata))}'
+      )
+    `);
+    }
+    async flush() {
+        // chdb writes are synchronous, nothing to flush
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Experiment Result Storage (direct API)
+    // ─────────────────────────────────────────────────────────────────────────────
+    async storeResult(result) {
+        await this.track({
+            type: 'variant.complete',
+            timestamp: result.completedAt,
+            data: {
+                experimentId: result.experimentId,
+                variantId: result.variantId,
+                variantName: result.variantName,
+                runId: result.runId,
+                success: result.success,
+                duration: result.duration,
+                result: result.result,
+                metricValue: result.metricValue,
+                error: result.error,
+                metadata: result.metadata,
+            },
+        });
+    }
+    async storeResults(results) {
+        for (const result of results) {
+            await this.storeResult(result);
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Analytics Queries
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Get all experiments
+     */
+    async getExperiments() {
+        await this.init();
+        const result = this.session.query(`
+      SELECT
+        experimentId,
+        any(experimentName) AS experimentName,
+        uniq(variantId) AS variantCount,
+        count() AS runCount,
+        min(timestamp) AS firstRun,
+        max(timestamp) AS lastRun
+      FROM experiments
+      WHERE experimentId != '' AND eventType = 'variant.complete'
+      GROUP BY experimentId
+      ORDER BY lastRun DESC
+    `, 'JSONEachRow');
+        if (!result.trim())
+            return [];
+        return result.trim().split('\n')
+            .filter(Boolean)
+            .map(line => JSON.parse(line));
+    }
+    /**
+     * Get variant performance for an experiment
+     */
+    async getVariantStats(experimentId) {
+        await this.init();
+        const result = this.session.query(`
+      SELECT
+        variantId,
+        any(variantName) AS variantName,
+        count() AS runCount,
+        countIf(success = 1) AS successCount,
+        countIf(success = 1) / count() AS successRate,
+        avg(durationMs) AS avgDuration,
+        avg(metricValue) AS avgMetric,
+        min(metricValue) AS minMetric,
+        max(metricValue) AS maxMetric
+      FROM experiments
+      WHERE experimentId = '${this.escapeString(experimentId)}'
+        AND eventType = 'variant.complete'
+      GROUP BY variantId
+      ORDER BY avgMetric DESC
+    `, 'JSONEachRow');
+        if (!result.trim())
+            return [];
+        return result.trim().split('\n')
+            .filter(Boolean)
+            .map(line => {
+            const row = JSON.parse(line);
+            return {
+                ...row,
+                runCount: Number(row.runCount),
+                successCount: Number(row.successCount),
+                successRate: Number(row.successRate),
+                avgDuration: Number(row.avgDuration),
+                avgMetric: Number(row.avgMetric),
+                minMetric: Number(row.minMetric),
+                maxMetric: Number(row.maxMetric),
+            };
+        });
+    }
+    /**
+     * Get the best performing variant for an experiment
+     */
+    async getBestVariant(experimentId, options = {}) {
+        const { metric = 'avgMetric', minimumRuns = 1 } = options;
+        await this.init();
+        const orderBy = metric === 'avgDuration' ? 'ASC' : 'DESC';
+        const metricExpr = metric === 'successRate'
+            ? 'countIf(success = 1) / count()'
+            : metric === 'avgDuration'
+                ? 'avg(durationMs)'
+                : 'avg(metricValue)';
+        const result = this.session.query(`
+      SELECT
+        variantId,
+        any(variantName) AS variantName,
+        ${metricExpr} AS metricValue,
+        count() AS runCount
+      FROM experiments
+      WHERE experimentId = '${this.escapeString(experimentId)}'
+        AND eventType = 'variant.complete'
+      GROUP BY variantId
+      HAVING runCount >= ${minimumRuns}
+      ORDER BY metricValue ${orderBy}
+      LIMIT 1
+    `, 'JSONEachRow');
+        if (!result.trim())
+            return null;
+        const firstLine = result.trim().split('\n')[0];
+        if (!firstLine)
+            return null;
+        const row = JSON.parse(firstLine);
+        return {
+            variantId: row.variantId,
+            variantName: row.variantName,
+            metricValue: Number(row.metricValue),
+            runCount: Number(row.runCount),
+        };
+    }
+    /**
+     * Get cartesian product analysis - performance by dimension values
+     */
+    async getCartesianAnalysis(experimentId, dimension) {
+        await this.init();
+        const result = this.session.query(`
+      SELECT
+        JSONExtractString(dimensions, '${this.escapeString(dimension)}') AS dimensionValue,
+        count() AS runCount,
+        avg(metricValue) AS avgMetric,
+        countIf(success = 1) / count() AS successRate
+      FROM experiments
+      WHERE experimentId = '${this.escapeString(experimentId)}'
+        AND eventType = 'variant.complete'
+        AND dimensionValue != ''
+      GROUP BY dimensionValue
+      ORDER BY avgMetric DESC
+    `, 'JSONEachRow');
+        if (!result.trim())
+            return [];
+        return result.trim().split('\n')
+            .filter(Boolean)
+            .map(line => {
+            const row = JSON.parse(line);
+            return {
+                dimensionValue: row.dimensionValue,
+                runCount: Number(row.runCount),
+                avgMetric: Number(row.avgMetric),
+                successRate: Number(row.successRate),
+            };
+        });
+    }
+    /**
+     * Get multi-dimensional cartesian analysis
+     */
+    async getCartesianGrid(experimentId, dimensions) {
+        await this.init();
+        const dimExtracts = dimensions.map(d => `JSONExtractString(dimensions, '${this.escapeString(d)}') AS dim_${d}`).join(', ');
+        const dimGroupBy = dimensions.map(d => `dim_${d}`).join(', ');
+        const result = this.session.query(`
+      SELECT
+        ${dimExtracts},
+        count() AS runCount,
+        avg(metricValue) AS avgMetric,
+        countIf(success = 1) / count() AS successRate
+      FROM experiments
+      WHERE experimentId = '${this.escapeString(experimentId)}'
+        AND eventType = 'variant.complete'
+      GROUP BY ${dimGroupBy}
+      ORDER BY avgMetric DESC
+    `, 'JSONEachRow');
+        if (!result.trim())
+            return [];
+        return result.trim().split('\n')
+            .filter(Boolean)
+            .map(line => {
+            const row = JSON.parse(line);
+            const dims = {};
+            for (const d of dimensions) {
+                dims[d] = row[`dim_${d}`];
+            }
+            return {
+                dimensions: dims,
+                runCount: Number(row.runCount),
+                avgMetric: Number(row.avgMetric),
+                successRate: Number(row.successRate),
+            };
+        });
+    }
+    /**
+     * Get time series of experiment metrics
+     */
+    async getTimeSeries(experimentId, options = {}) {
+        const { interval = 'day', variantId } = options;
+        await this.init();
+        const dateFunc = interval === 'hour'
+            ? 'toStartOfHour(timestamp)'
+            : interval === 'week'
+                ? 'toStartOfWeek(timestamp)'
+                : 'toStartOfDay(timestamp)';
+        const variantFilter = variantId
+            ? `AND variantId = '${this.escapeString(variantId)}'`
+            : '';
+        const result = this.session.query(`
+      SELECT
+        ${dateFunc} AS period,
+        count() AS runCount,
+        avg(metricValue) AS avgMetric,
+        countIf(success = 1) / count() AS successRate
+      FROM experiments
+      WHERE experimentId = '${this.escapeString(experimentId)}'
+        AND eventType = 'variant.complete'
+        ${variantFilter}
+      GROUP BY period
+      ORDER BY period ASC
+    `, 'JSONEachRow');
+        if (!result.trim())
+            return [];
+        return result.trim().split('\n')
+            .filter(Boolean)
+            .map(line => {
+            const row = JSON.parse(line);
+            return {
+                period: row.period,
+                runCount: Number(row.runCount),
+                avgMetric: Number(row.avgMetric),
+                successRate: Number(row.successRate),
+            };
+        });
+    }
+    /**
+     * Get raw events for an experiment
+     */
+    async getEvents(experimentId, options = {}) {
+        const { eventType, variantId, limit = 100 } = options;
+        await this.init();
+        const filters = [`experimentId = '${this.escapeString(experimentId)}'`];
+        if (eventType)
+            filters.push(`eventType = '${this.escapeString(eventType)}'`);
+        if (variantId)
+            filters.push(`variantId = '${this.escapeString(variantId)}'`);
+        const result = this.session.query(`
+      SELECT
+        eventType,
+        timestamp,
+        experimentId,
+        experimentName,
+        variantId,
+        variantName,
+        dimensions,
+        runId,
+        success,
+        durationMs,
+        result,
+        metricName,
+        metricValue,
+        errorMessage,
+        metadata
+      FROM experiments
+      WHERE ${filters.join(' AND ')}
+      ORDER BY timestamp DESC
+      LIMIT ${limit}
+    `, 'JSONEachRow');
+        if (!result.trim())
+            return [];
+        return result.trim().split('\n')
+            .filter(Boolean)
+            .map(line => {
+            const row = JSON.parse(line);
+            return {
+                type: row.eventType,
+                timestamp: new Date(row.timestamp),
+                data: {
+                    experimentId: row.experimentId,
+                    experimentName: row.experimentName,
+                    variantId: row.variantId,
+                    variantName: row.variantName,
+                    dimensions: this.parseJson(row.dimensions),
+                    runId: row.runId,
+                    success: row.success === 1,
+                    duration: row.durationMs,
+                    result: this.parseJson(row.result),
+                    metricName: row.metricName,
+                    metricValue: row.metricValue,
+                    errorMessage: row.errorMessage,
+                    metadata: this.parseJson(row.metadata),
+                },
+            };
+        });
+    }
+    /**
+     * Raw SQL query access for custom analytics
+     */
+    query(sql, format = 'JSONEachRow') {
+        return this.session.query(sql, format);
+    }
+    /**
+     * Close the storage (cleanup)
+     */
+    close() {
+        // Session cleanup handled by chdb
+    }
+}
+/**
+ * Create a chdb storage backend for experiments
+ *
+ * @example
+ * ```ts
+ * import { configureTracking } from 'ai-experiments'
+ * import { createChdbBackend } from 'ai-experiments/storage'
+ *
+ * const storage = createChdbBackend({ dataPath: './.my-experiments' })
+ *
+ * configureTracking({ backend: storage })
+ *
+ * // Later: analyze results
+ * const best = await storage.getBestVariant('my-experiment')
+ * console.log(`Best variant: ${best.variantName} (${best.metricValue})`)
+ * ```
+ */
+export function createChdbBackend(options) {
+    return new ChdbStorage(options);
+}
+//# sourceMappingURL=chdb-storage.js.map