@hazeljs/ml 0.2.4 → 0.3.0

package/dist/experiments/__tests__/experiment.service.test.js

@@ -0,0 +1,460 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const experiment_service_1 = require("../experiment.service");
+const fs_1 = require("fs");
+const path_1 = require("path");
+describe('ExperimentService', () => {
+    let service;
+    const testStorageDir = (0, path_1.join)(__dirname, '__test_experiments__');
+    beforeEach(() => {
+        service = new experiment_service_1.ExperimentService();
+    });
+    afterEach(() => {
+        if ((0, fs_1.existsSync)(testStorageDir)) {
+            (0, fs_1.rmSync)(testStorageDir, { recursive: true, force: true });
+        }
+    });
+    describe('configure', () => {
+        it('should configure with memory storage', () => {
+            service.configure({ storage: 'memory' });
+            expect(() => service.listExperiments()).not.toThrow();
+        });
+        it('should configure with file storage', () => {
+            service.configure({
+                storage: 'file',
+                file: { directory: testStorageDir },
+            });
+            expect(() => service.listExperiments()).not.toThrow();
+        });
+    });
+    describe('createExperiment', () => {
+        it('should create experiment with name', () => {
+            const exp = service.createExperiment('test-exp');
+            expect(exp.id).toBeDefined();
+            expect(exp.name).toBe('test-exp');
+            expect(exp.createdAt).toBeInstanceOf(Date);
+            expect(exp.updatedAt).toBeInstanceOf(Date);
+        });
+        it('should create experiment with description', () => {
+            const exp = service.createExperiment('test-exp', {
+                description: 'Test experiment',
+            });
+            expect(exp.description).toBe('Test experiment');
+        });
+        it('should create experiment with tags', () => {
+            const exp = service.createExperiment('test-exp', {
+                tags: ['ml', 'test'],
+            });
+            expect(exp.tags).toEqual(['ml', 'test']);
+        });
+        it('should create experiment without optional fields', () => {
+            const exp = service.createExperiment('test-exp');
+            expect(exp.description).toBeUndefined();
+            expect(exp.tags).toBeUndefined();
+        });
+    });
+    describe('getExperiment', () => {
+        it('should return experiment by id', () => {
+            const exp = service.createExperiment('test-exp');
+            const retrieved = service.getExperiment(exp.id);
+            expect(retrieved).toEqual(exp);
+        });
+        it('should return undefined for non-existent experiment', () => {
+            expect(service.getExperiment('non-existent')).toBeUndefined();
+        });
+    });
+    describe('listExperiments', () => {
+        it('should return empty array when no experiments', () => {
+            expect(service.listExperiments()).toEqual([]);
+        });
+        it('should list all experiments', () => {
+            const exp1 = service.createExperiment('exp1');
+            const exp2 = service.createExperiment('exp2');
+            const experiments = service.listExperiments();
+            expect(experiments).toHaveLength(2);
+            expect(experiments).toContainEqual(exp1);
+            expect(experiments).toContainEqual(exp2);
+        });
+    });
+    describe('deleteExperiment', () => {
+        it('should delete experiment', () => {
+            const exp = service.createExperiment('test-exp');
+            const deleted = service.deleteExperiment(exp.id);
+            expect(deleted).toBe(true);
+            expect(service.getExperiment(exp.id)).toBeUndefined();
+        });
+        it('should return false for non-existent experiment', () => {
+            expect(service.deleteExperiment('non-existent')).toBe(false);
+        });
+        it('should delete associated runs when deleting experiment', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            service.deleteExperiment(exp.id);
+            expect(service.getRun(run.id)).toBeUndefined();
+        });
+    });
+    describe('startRun', () => {
+        it('should start run for experiment', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            expect(run.id).toBeDefined();
+            expect(run.experimentId).toBe(exp.id);
+            expect(run.status).toBe('running');
+            expect(run.startTime).toBeInstanceOf(Date);
+            expect(run.params).toEqual({});
+            expect(run.metrics).toEqual({});
+            expect(run.artifacts).toEqual([]);
+        });
+        it('should start run with name', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id, { name: 'test-run' });
+            expect(run.name).toBe('test-run');
+        });
+        it('should start run with params', () => {
+            const exp = service.createExperiment('test-exp');
+            const params = { lr: 0.001, epochs: 10 };
+            const run = service.startRun(exp.id, { params });
+            expect(run.params).toEqual(params);
+        });
+        it('should start run with tags', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id, { tags: ['baseline', 'v1'] });
+            expect(run.tags).toEqual(['baseline', 'v1']);
+        });
+    });
+    describe('endRun', () => {
+        it('should end run with completed status', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            const endedRun = service.endRun(run.id, 'completed');
+            expect(endedRun.status).toBe('completed');
+            expect(endedRun.endTime).toBeInstanceOf(Date);
+            expect(endedRun.durationMs).toBeGreaterThanOrEqual(0);
+        });
+        it('should end run with failed status', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            const endedRun = service.endRun(run.id, 'failed');
+            expect(endedRun.status).toBe('failed');
+        });
+        it('should end run with aborted status', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            const endedRun = service.endRun(run.id, 'aborted');
+            expect(endedRun.status).toBe('aborted');
+        });
+        it('should default to completed status', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            const endedRun = service.endRun(run.id);
+            expect(endedRun.status).toBe('completed');
+        });
+        it('should throw error for non-existent run', () => {
+            expect(() => service.endRun('non-existent')).toThrow('Run not found');
+        });
+        it('should calculate duration', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            const endedRun = service.endRun(run.id);
+            expect(endedRun.durationMs).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('getRun', () => {
+        it('should return run by id', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            const retrieved = service.getRun(run.id);
+            expect(retrieved).toEqual(run);
+        });
+        it('should return undefined for non-existent run', () => {
+            expect(service.getRun('non-existent')).toBeUndefined();
+        });
+    });
+    describe('listRuns', () => {
+        it('should return empty array when no runs', () => {
+            expect(service.listRuns()).toEqual([]);
+        });
+        it('should list all runs', () => {
+            const exp = service.createExperiment('test-exp');
+            const run1 = service.startRun(exp.id);
+            const run2 = service.startRun(exp.id);
+            const runs = service.listRuns();
+            expect(runs).toHaveLength(2);
+            expect(runs).toContainEqual(run1);
+            expect(runs).toContainEqual(run2);
+        });
+        it('should filter runs by experiment id', () => {
+            const exp1 = service.createExperiment('exp1');
+            const exp2 = service.createExperiment('exp2');
+            const run1 = service.startRun(exp1.id);
+            const _run2 = service.startRun(exp2.id);
+            const runs = service.listRuns(exp1.id);
+            expect(runs).toHaveLength(1);
+            expect(runs[0]).toEqual(run1);
+        });
+    });
+    describe('deleteRun', () => {
+        it('should delete run', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            const deleted = service.deleteRun(run.id);
+            expect(deleted).toBe(true);
+            expect(service.getRun(run.id)).toBeUndefined();
+        });
+        it('should return false for non-existent run', () => {
+            expect(service.deleteRun('non-existent')).toBe(false);
+        });
+    });
+    describe('logMetric', () => {
+        it('should log metric to run', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            service.logMetric(run.id, 'accuracy', 0.95);
+            const updatedRun = service.getRun(run.id);
+            expect(updatedRun?.metrics.accuracy).toBe(0.95);
+        });
+        it('should throw error for non-existent run', () => {
+            expect(() => service.logMetric('non-existent', 'metric', 0.5)).toThrow('Run not found');
+        });
+    });
+    describe('logArtifact', () => {
+        it('should log artifact to run', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            const artifact = service.logArtifact(run.id, 'trained-model', 'model', 'model content');
+            expect(artifact.name).toBe('trained-model');
+            expect(artifact.type).toBe('model');
+            const updatedRun = service.getRun(run.id);
+            expect(updatedRun?.artifacts).toHaveLength(1);
+            expect(updatedRun?.artifacts[0].name).toBe('trained-model');
+            expect(updatedRun?.artifacts[0].type).toBe('model');
+        });
+        it('should throw error for non-existent run', () => {
+            expect(() => service.logArtifact('non-existent', 'name', 'model', 'content')).toThrow('Run not found');
+        });
+        it('should support different artifact types', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            service.logArtifact(run.id, 'plot1', 'plot', 'plot data');
+            service.logArtifact(run.id, 'log1', 'log', 'log data');
+            service.logArtifact(run.id, 'data1', 'data', 'data content');
+            service.logArtifact(run.id, 'other1', 'other', 'other content');
+            const updatedRun = service.getRun(run.id);
+            expect(updatedRun?.artifacts).toHaveLength(4);
+        });
+    });
+    describe('compareRuns', () => {
+        it('should compare two completed runs', () => {
+            const exp = service.createExperiment('test-exp');
+            const run1 = service.startRun(exp.id, { params: { lr: 0.001 } });
+            const run2 = service.startRun(exp.id, { params: { lr: 0.01 } });
+            service.logMetric(run1.id, 'accuracy', 0.9);
+            service.logMetric(run2.id, 'accuracy', 0.95);
+            service.endRun(run1.id, 'completed');
+            service.endRun(run2.id, 'completed');
+            const comparisons = service.compareRuns([run1.id, run2.id]);
+            expect(comparisons).toHaveLength(2);
+            expect(comparisons[0].runId).toBe(run1.id);
+            expect(comparisons[0].params).toEqual({ lr: 0.001 });
+            expect(comparisons[0].metrics.accuracy).toBe(0.9);
+            expect(comparisons[1].runId).toBe(run2.id);
+        });
+        it('should handle empty run list', () => {
+            const comparisons = service.compareRuns([]);
+            expect(comparisons).toEqual([]);
+        });
+        it('should filter out non-completed runs', () => {
+            const exp = service.createExperiment('test-exp');
+            const run1 = service.startRun(exp.id);
+            const run2 = service.startRun(exp.id);
+            service.endRun(run1.id, 'completed');
+            // run2 is still running
+            const comparisons = service.compareRuns([run1.id, run2.id]);
+            expect(comparisons).toHaveLength(1);
+            expect(comparisons[0].runId).toBe(run1.id);
+        });
+    });
+    describe('getBestRun', () => {
+        it('should return run with highest metric value', () => {
+            const exp = service.createExperiment('test-exp');
+            const run1 = service.startRun(exp.id);
+            const run2 = service.startRun(exp.id);
+            service.logMetric(run1.id, 'accuracy', 0.9);
+            service.logMetric(run2.id, 'accuracy', 0.95);
+            const best = service.getBestRun(exp.id, 'accuracy', 'max');
+            expect(best?.id).toBe(run2.id);
+        });
+        it('should return run with lowest metric value', () => {
+            const exp = service.createExperiment('test-exp');
+            const run1 = service.startRun(exp.id);
+            const run2 = service.startRun(exp.id);
+            service.logMetric(run1.id, 'loss', 0.5);
+            service.logMetric(run2.id, 'loss', 0.3);
+            const best = service.getBestRun(exp.id, 'loss', 'min');
+            expect(best?.id).toBe(run2.id);
+        });
+        it('should return undefined when no runs have the metric', () => {
+            const exp = service.createExperiment('test-exp');
+            service.startRun(exp.id);
+            const best = service.getBestRun(exp.id, 'accuracy', 'max');
+            expect(best).toBeUndefined();
+        });
+        it('should return undefined for experiment with no runs', () => {
+            const exp = service.createExperiment('test-exp');
+            const best = service.getBestRun(exp.id, 'accuracy', 'max');
+            expect(best).toBeUndefined();
+        });
+    });
+    describe('logMetrics', () => {
+        it('should log multiple metrics at once', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            service.logMetrics(run.id, {
+                accuracy: 0.95,
+                precision: 0.92,
+                recall: 0.88,
+            });
+            const updatedRun = service.getRun(run.id);
+            expect(updatedRun?.metrics.accuracy).toBe(0.95);
+            expect(updatedRun?.metrics.precision).toBe(0.92);
+            expect(updatedRun?.metrics.recall).toBe(0.88);
+        });
+    });
+    describe('file storage', () => {
+        it('should work with file storage configuration', () => {
+            if (!(0, fs_1.existsSync)(testStorageDir)) {
+                (0, fs_1.mkdirSync)(testStorageDir, { recursive: true });
+            }
+            service.configure({
+                storage: 'file',
+                file: { directory: testStorageDir },
+            });
+            const exp = service.createExperiment('file-test');
+            const run = service.startRun(exp.id);
+            service.logMetric(run.id, 'accuracy', 0.95);
+            service.endRun(run.id);
+            // Verify we can retrieve from file storage
+            const retrieved = service.getExperiment(exp.id);
+            expect(retrieved?.name).toBe('file-test');
+            const retrievedRun = service.getRun(run.id);
+            expect(retrievedRun?.metrics.accuracy).toBe(0.95);
+        });
+        it('should list experiments from file storage', () => {
+            if (!(0, fs_1.existsSync)(testStorageDir)) {
+                (0, fs_1.mkdirSync)(testStorageDir, { recursive: true });
+            }
+            service.configure({
+                storage: 'file',
+                file: { directory: testStorageDir },
+            });
+            service.createExperiment('exp1');
+            service.createExperiment('exp2');
+            const experiments = service.listExperiments();
+            expect(experiments.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should list runs from file storage', () => {
+            if (!(0, fs_1.existsSync)(testStorageDir)) {
+                (0, fs_1.mkdirSync)(testStorageDir, { recursive: true });
+            }
+            service.configure({
+                storage: 'file',
+                file: { directory: testStorageDir },
+            });
+            const exp = service.createExperiment('run-test');
+            service.startRun(exp.id);
+            service.startRun(exp.id);
+            const runs = service.listRuns(exp.id);
+            expect(runs.length).toBeGreaterThanOrEqual(2);
+        });
+        it('should delete experiment with file storage', () => {
+            if (!(0, fs_1.existsSync)(testStorageDir)) {
+                (0, fs_1.mkdirSync)(testStorageDir, { recursive: true });
+            }
+            service.configure({
+                storage: 'file',
+                file: { directory: testStorageDir },
+            });
+            const exp = service.createExperiment('delete-test');
+            const run = service.startRun(exp.id);
+            service.deleteExperiment(exp.id);
+            expect(service.getExperiment(exp.id)).toBeUndefined();
+            expect(service.getRun(run.id)).toBeUndefined();
+        });
+        it('should delete run with file storage', () => {
+            if (!(0, fs_1.existsSync)(testStorageDir)) {
+                (0, fs_1.mkdirSync)(testStorageDir, { recursive: true });
+            }
+            service.configure({
+                storage: 'file',
+                file: { directory: testStorageDir },
+            });
+            const exp = service.createExperiment('run-delete-test');
+            const run = service.startRun(exp.id);
+            service.deleteRun(run.id);
+            expect(service.getRun(run.id)).toBeUndefined();
+        });
+        it('should log artifact with file storage', () => {
+            if (!(0, fs_1.existsSync)(testStorageDir)) {
+                (0, fs_1.mkdirSync)(testStorageDir, { recursive: true });
+            }
+            service.configure({
+                storage: 'file',
+                file: { directory: testStorageDir },
+            });
+            const exp = service.createExperiment('artifact-test');
+            const run = service.startRun(exp.id);
+            const artifact = service.logArtifact(run.id, 'model', 'model', 'model data');
+            expect(artifact.path).toBeDefined();
+            expect(artifact.size).toBeGreaterThan(0);
+        });
+        it('should handle non-existent experiment in file storage', () => {
+            if (!(0, fs_1.existsSync)(testStorageDir)) {
+                (0, fs_1.mkdirSync)(testStorageDir, { recursive: true });
+            }
+            service.configure({
+                storage: 'file',
+                file: { directory: testStorageDir },
+            });
+            expect(service.getExperiment('non-existent')).toBeUndefined();
+        });
+        it('should handle non-existent run in file storage', () => {
+            if (!(0, fs_1.existsSync)(testStorageDir)) {
+                (0, fs_1.mkdirSync)(testStorageDir, { recursive: true });
+            }
+            service.configure({
+                storage: 'file',
+                file: { directory: testStorageDir },
+            });
+            expect(service.getRun('non-existent')).toBeUndefined();
+        });
+        it('should return empty array when no experiments in file storage', () => {
+            const emptyDir = (0, path_1.join)(testStorageDir, 'empty');
+            if (!(0, fs_1.existsSync)(emptyDir)) {
+                (0, fs_1.mkdirSync)(emptyDir, { recursive: true });
+            }
+            service.configure({
+                storage: 'file',
+                file: { directory: emptyDir },
+            });
+            expect(service.listExperiments()).toEqual([]);
+        });
+    });
+    describe('getArtifact', () => {
+        it('should get artifact by id', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            const artifact = service.logArtifact(run.id, 'model', 'model', 'data');
+            const retrieved = service.getArtifact(run.id, artifact.id);
+            expect(retrieved).toBeDefined();
+            expect(retrieved?.id).toBe(artifact.id);
+        });
+        it('should return undefined for non-existent artifact', () => {
+            const exp = service.createExperiment('test-exp');
+            const run = service.startRun(exp.id);
+            expect(service.getArtifact(run.id, 'non-existent')).toBeUndefined();
+        });
+        it('should return undefined for non-existent run', () => {
+            expect(service.getArtifact('non-existent', 'artifact-id')).toBeUndefined();
+        });
+    });
+});

package/dist/experiments/experiment.decorator.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @Experiment decorator - Auto-track training runs
+ */
+import 'reflect-metadata';
+export declare const EXPERIMENT_METADATA_KEY: unique symbol;
+export interface ExperimentOptions {
+    name?: string;
+    description?: string;
+    tags?: string[];
+    autoLogParams?: boolean;
+    autoLogMetrics?: boolean;
+}
+export interface ExperimentMetadata {
+    name: string;
+    description?: string;
+    tags?: string[];
+    autoLogParams: boolean;
+    autoLogMetrics: boolean;
+}
+/**
+ * Mark a class as an ML experiment for auto-tracking.
+ * When combined with @Train, training runs are automatically logged.
+ *
+ * @example
+ * ```typescript
+ * @Experiment({
+ *   name: 'sentiment-classifier',
+ *   description: 'Training sentiment classification models',
+ *   tags: ['nlp', 'classification']
+ * })
+ * @Model({ name: 'sentiment', version: '1.0.0', framework: 'custom' })
+ * @Injectable()
+ * class SentimentClassifier {
+ *   @Train()
+ *   async train(data: TrainingData) {
+ *     // This run will be automatically tracked
+ *   }
+ * }
+ * ```
+ */
+export declare function Experiment(options?: ExperimentOptions): ClassDecorator;
+export declare function getExperimentMetadata(target: object): ExperimentMetadata | undefined;
+export declare function hasExperimentMetadata(target: object): boolean;
+//# sourceMappingURL=experiment.decorator.d.ts.map

package/dist/experiments/experiment.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experiment.decorator.d.ts","sourceRoot":"","sources":["../../src/experiments/experiment.decorator.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,kBAAkB,CAAC;AAE1B,eAAO,MAAM,uBAAuB,eAAsC,CAAC;AAE3E,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;IACvB,cAAc,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,cAAc,CAa1E;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAEpF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE7D"}

package/dist/experiments/experiment.decorator.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * @Experiment decorator - Auto-track training runs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPERIMENT_METADATA_KEY = void 0;
+exports.Experiment = Experiment;
+exports.getExperimentMetadata = getExperimentMetadata;
+exports.hasExperimentMetadata = hasExperimentMetadata;
+require("reflect-metadata");
+exports.EXPERIMENT_METADATA_KEY = Symbol('hazel:experiment:metadata');
+/**
+ * Mark a class as an ML experiment for auto-tracking.
+ * When combined with @Train, training runs are automatically logged.
+ *
+ * @example
+ * ```typescript
+ * @Experiment({
+ *   name: 'sentiment-classifier',
+ *   description: 'Training sentiment classification models',
+ *   tags: ['nlp', 'classification']
+ * })
+ * @Model({ name: 'sentiment', version: '1.0.0', framework: 'custom' })
+ * @Injectable()
+ * class SentimentClassifier {
+ *   @Train()
+ *   async train(data: TrainingData) {
+ *     // This run will be automatically tracked
+ *   }
+ * }
+ * ```
+ */
+function Experiment(options = {}) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    return function (target) {
+        const metadata = {
+            name: options.name ?? target.name,
+            description: options.description,
+            tags: options.tags,
+            autoLogParams: options.autoLogParams ?? true,
+            autoLogMetrics: options.autoLogMetrics ?? true,
+        };
+        Reflect.defineMetadata(exports.EXPERIMENT_METADATA_KEY, metadata, target);
+    };
+}
+function getExperimentMetadata(target) {
+    return Reflect.getMetadata(exports.EXPERIMENT_METADATA_KEY, target);
+}
+function hasExperimentMetadata(target) {
+    return Reflect.hasMetadata(exports.EXPERIMENT_METADATA_KEY, target);
+}

package/dist/experiments/experiment.service.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Experiment Service - ML experiment tracking and management
+ */
+import type { Experiment, Run, Artifact, ExperimentConfig, RunComparison } from './experiment.types';
+export declare class ExperimentService {
+    private experiments;
+    private runs;
+    private config;
+    private storageDir;
+    configure(config: ExperimentConfig): void;
+    createExperiment(name: string, options?: {
+        description?: string;
+        tags?: string[];
+    }): Experiment;
+    getExperiment(id: string): Experiment | undefined;
+    listExperiments(): Experiment[];
+    deleteExperiment(id: string): boolean;
+    startRun(experimentId: string, options?: {
+        name?: string;
+        params?: Record<string, unknown>;
+        tags?: string[];
+    }): Run;
+    endRun(runId: string, status?: 'completed' | 'failed' | 'aborted'): Run;
+    getRun(id: string): Run | undefined;
+    listRuns(experimentId?: string): Run[];
+    deleteRun(id: string): boolean;
+    logMetric(runId: string, key: string, value: number): void;
+    logMetrics(runId: string, metrics: Record<string, number>): void;
+    getBestRun(experimentId: string, metric: string, mode?: 'min' | 'max'): Run | undefined;
+    logArtifact(runId: string, name: string, type: Artifact['type'], content: string | Buffer, metadata?: Record<string, unknown>): Artifact;
+    getArtifact(runId: string, artifactId: string): Artifact | undefined;
+    compareRuns(runIds: string[]): RunComparison[];
+    private saveExperimentToFile;
+    private loadExperimentFromFile;
+    private loadAllExperimentsFromFile;
+    private saveRunToFile;
+    private loadRunFromFile;
+    private loadAllRunsFromFile;
+    private deleteArtifactFile;
+    private getArtifactExtension;
+}
+//# sourceMappingURL=experiment.service.d.ts.map

package/dist/experiments/experiment.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experiment.service.d.ts","sourceRoot":"","sources":["../../src/experiments/experiment.service.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,KAAK,EACV,UAAU,EACV,GAAG,EACH,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACd,MAAM,oBAAoB,CAAC;AAM5B,qBACa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAAsC;IACzD,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,MAAM,CAA2C;IACzD,OAAO,CAAC,UAAU,CAA2B;IAE7C,SAAS,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAUzC,gBAAgB,CACd,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO,GACtD,UAAU;IAoBb,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAOjD,eAAe,IAAI,UAAU,EAAE;IAO/B,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IA0BrC,QAAQ,CACN,YAAY,EAAE,MAAM,EACpB,OAAO,GAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;KAAO,GACjF,GAAG;IAuBN,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,WAAW,GAAG,QAAQ,GAAG,SAAuB,GAAG,GAAG;IAkBpF,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS;IAOnC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE;IAgBtC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAuB9B,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAe1D,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAMhE,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,KAAK,GAAG,KAAa,GAAG,GAAG,GAAG,SAAS;IAkB9F,WAAW,CACT,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,EACtB,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,QAAQ;IAiDX,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IASpE,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,aAAa,EAAE;IAc9C,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,0BAA0B;IAgBlC,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,eAAe;IAuBvB,OAAO,CAAC,mBAAmB;IAuB3B,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,oBAAoB;CAc7B"}