@artemiskit/core 0.1.2

package/dist/scenario/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/scenario/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,cAAc,mIAWzB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoBpB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2CzB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;EAG5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,eAAe,gFAAuE,CAAC;AAEpG;;;GAGG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;GAAuC,CAAC;AAEnE;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAazB,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7D,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAYzB,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAnB7C,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiC7D,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAChE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/scenario/variables.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Variable substitution for scenario templates
+ * Supports {{variable}} syntax in strings
+ */
+import type { Variables } from './schema';
+/**
+ * Substitute variables in a string using {{variable}} syntax
+ */
+export declare function substituteString(str: string, variables: Variables): string;
+/**
+ * Recursively substitute variables in an object
+ * Only substitutes in string values, preserving other types
+ */
+export declare function substituteVariables<T>(obj: T, variables: Variables): T;
+/**
+ * Merge variables with case-level overriding scenario-level
+ */
+export declare function mergeVariables(scenarioVars: Variables | undefined, caseVars: Variables | undefined): Variables;
+//# sourceMappingURL=variables.d.ts.map

package/dist/scenario/variables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variables.d.ts","sourceRoot":"","sources":["../../src/scenario/variables.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE1C;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,CAQ1E;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,SAAS,EAAE,SAAS,GAAG,CAAC,CAsBtE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,YAAY,EAAE,SAAS,GAAG,SAAS,EACnC,QAAQ,EAAE,SAAS,GAAG,SAAS,GAC9B,SAAS,CAKX"}

package/dist/storage/factory.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Storage factory for creating storage adapters
+ */
+import type { StorageAdapter, StorageConfig } from './types';
+/**
+ * Create a storage adapter from configuration
+ */
+export declare function createStorageAdapter(config: StorageConfig): StorageAdapter;
+/**
+ * Create storage adapter from environment variables
+ */
+export declare function createStorageFromEnv(): StorageAdapter;
+//# sourceMappingURL=factory.d.ts.map

package/dist/storage/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/storage/factory.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7D;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc,CAqB1E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,cAAc,CAarD"}

package/dist/storage/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Storage module exports
+ */
+export * from './types';
+export { createStorageAdapter, createStorageFromEnv } from './factory';
+export { SupabaseStorageAdapter, type SupabaseStorageConfig } from './supabase';
+export { LocalStorageAdapter } from './local';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC"}

package/dist/storage/local.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Local filesystem storage adapter
+ */
+import type { AnyManifest, RedTeamManifest, RunManifest, StressManifest } from '../artifacts/types';
+import type { ComparisonResult, ListOptions, RunListItem, StorageAdapter } from './types';
+export declare class LocalStorageAdapter implements StorageAdapter {
+    private basePath;
+    constructor(basePath?: string);
+    save(manifest: AnyManifest): Promise<string>;
+    load(runId: string): Promise<AnyManifest>;
+    loadRun(runId: string): Promise<RunManifest>;
+    loadRedTeam(runId: string): Promise<RedTeamManifest>;
+    loadStress(runId: string): Promise<StressManifest>;
+    list(options?: ListOptions): Promise<RunListItem[]>;
+    delete(runId: string): Promise<void>;
+    compare(baselineId: string, currentId: string): Promise<ComparisonResult>;
+    private listDirectories;
+    private listFiles;
+}
+//# sourceMappingURL=local.d.ts.map

package/dist/storage/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../src/storage/local.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpG,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAkC1F,qBAAa,mBAAoB,YAAW,cAAc;IACxD,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,SAAmB;IAIjC,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAU5C,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAczC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAQ5C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAQpD,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAQlD,IAAI,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAmDnD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYpC,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;YAiBjE,eAAe;YASf,SAAS;CAQxB"}

package/dist/storage/supabase.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Supabase storage adapter
+ */
+import type { RunManifest } from '../artifacts/types';
+import type { ComparisonResult, ListOptions, RunListItem, StorageAdapter } from './types';
+export interface SupabaseStorageConfig {
+    url: string;
+    anonKey: string;
+    bucket?: string;
+}
+export declare class SupabaseStorageAdapter implements StorageAdapter {
+    private client;
+    private bucket;
+    constructor(config: SupabaseStorageConfig);
+    save(manifest: RunManifest): Promise<string>;
+    load(runId: string): Promise<RunManifest>;
+    list(options?: ListOptions): Promise<RunListItem[]>;
+    delete(runId: string): Promise<void>;
+    compare(baselineId: string, currentId: string): Promise<ComparisonResult>;
+}
+//# sourceMappingURL=supabase.d.ts.map

package/dist/storage/supabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supabase.d.ts","sourceRoot":"","sources":["../../src/storage/supabase.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE1F,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,sBAAuB,YAAW,cAAc;IAC3D,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,qBAAqB;IAKnC,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IA4C5C,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAuBzC,IAAI,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAiCnD,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAcpC,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAahF"}

package/dist/storage/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Storage types and interfaces
+ */
+import type { AnyManifest, RedTeamManifest, RunManifest, StressManifest } from '../artifacts/types';
+/**
+ * Run listing item
+ */
+export interface RunListItem {
+    runId: string;
+    scenario: string;
+    successRate: number;
+    createdAt: string;
+    /** Type of manifest (run, redteam, stress) */
+    type?: 'run' | 'redteam' | 'stress';
+}
+/**
+ * Comparison result between two runs
+ */
+export interface ComparisonResult {
+    baseline: RunManifest;
+    current: RunManifest;
+    delta: {
+        successRate: number;
+        latency: number;
+        tokens: number;
+    };
+}
+/**
+ * List options for filtering runs
+ */
+export interface ListOptions {
+    project?: string;
+    scenario?: string;
+    limit?: number;
+    offset?: number;
+    /** Filter by manifest type */
+    type?: 'run' | 'redteam' | 'stress';
+}
+/**
+ * Storage adapter interface - implement to create custom storage backends
+ */
+export interface StorageAdapter {
+    /**
+     * Save a run manifest (any type)
+     */
+    save(manifest: AnyManifest): Promise<string>;
+    /**
+     * Load a run manifest by ID
+     */
+    load(runId: string): Promise<AnyManifest>;
+    /**
+     * Load a standard run manifest by ID
+     */
+    loadRun?(runId: string): Promise<RunManifest>;
+    /**
+     * Load a red team manifest by ID
+     */
+    loadRedTeam?(runId: string): Promise<RedTeamManifest>;
+    /**
+     * Load a stress manifest by ID
+     */
+    loadStress?(runId: string): Promise<StressManifest>;
+    /**
+     * List runs with optional filters
+     */
+    list(options?: ListOptions): Promise<RunListItem[]>;
+    /**
+     * Delete a run
+     */
+    delete(runId: string): Promise<void>;
+    /**
+     * Compare two runs
+     */
+    compare?(baselineId: string, currentId: string): Promise<ComparisonResult>;
+}
+/**
+ * Storage configuration
+ */
+export interface StorageConfig {
+    type: 'supabase' | 'local';
+    url?: string;
+    anonKey?: string;
+    bucket?: string;
+    basePath?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/storage/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/storage/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpG;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,EAAE,WAAW,CAAC;IACrB,KAAK,EAAE;QACL,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,IAAI,CAAC,EAAE,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,IAAI,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAE7C;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAE1C;;OAEG;IACH,OAAO,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAE9C;;OAEG;IACH,WAAW,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAEtD;;OAEG;IACH,UAAU,CAAC,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAEpD;;OAEG;IACH,IAAI,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAEpD;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErC;;OAEG;IACH,OAAO,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC5E;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/dist/utils/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Error handling utilities for Artemis
+ */
+/**
+ * Error codes used throughout Artemis
+ */
+export type ArtemisErrorCode = 'UNKNOWN_PROVIDER' | 'PROVIDER_UNAVAILABLE' | 'SCENARIO_READ_ERROR' | 'SCENARIO_PARSE_ERROR' | 'SCENARIO_VALIDATION_ERROR' | 'ADAPTER_ERROR' | 'GENERATION_ERROR' | 'EVALUATION_ERROR' | 'STORAGE_ERROR' | 'CONFIG_ERROR' | 'UNKNOWN_ERROR';
+/**
+ * Custom error class for Artemis
+ */
+export declare class ArtemisError extends Error {
+    readonly code: ArtemisErrorCode;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code?: ArtemisErrorCode, details?: Record<string, unknown>);
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Check if error is an ArtemisError
+ */
+export declare function isArtemisError(error: unknown): error is ArtemisError;
+/**
+ * Wrap unknown errors in ArtemisError
+ */
+export declare function wrapError(error: unknown, code?: ArtemisErrorCode, context?: string): ArtemisError;
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/utils/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,gBAAgB,GACxB,kBAAkB,GAClB,sBAAsB,GACtB,qBAAqB,GACrB,sBAAsB,GACtB,2BAA2B,GAC3B,eAAe,GACf,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,cAAc,GACd,eAAe,CAAC;AAEpB;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAGzC,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,gBAAkC,EACxC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAUnC,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CASlC;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,OAAO,EACd,IAAI,GAAE,gBAAkC,EACxC,OAAO,CAAC,EAAE,MAAM,GACf,YAAY,CAUd"}

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Utilities module exports
+ */
+export * from './errors';
+export * from './logger';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Logger utility for Artemis
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Logger class for consistent logging across Artemis
+ */
+export declare class Logger {
+    private logger;
+    constructor(name: string);
+    debug(message: string, data?: Record<string, unknown>): void;
+    info(message: string, data?: Record<string, unknown>): void;
+    warn(message: string, data?: Record<string, unknown>): void;
+    error(message: string, error?: Error | unknown, data?: Record<string, unknown>): void;
+    child(bindings: Record<string, unknown>): Logger;
+}
+/**
+ * Default logger instance
+ */
+export declare const logger: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAY3D;;GAEG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAc;gBAEhB,IAAI,EAAE,MAAM;IAIxB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI5D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI3D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAI3D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAQrF,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;CAKjD;AAED;;GAEG;AACH,eAAO,MAAM,MAAM,QAAwB,CAAC"}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@artemiskit/core",
+  "version": "0.1.2",
+  "description": "Core runner, evaluators, and storage for ArtemisKit LLM evaluation toolkit",
+  "type": "module",
+  "license": "Apache-2.0",
+  "author": "code-sensei",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/code-sensei/artemiskit.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/code-sensei/artemiskit/issues"
+  },
+  "keywords": [
+    "llm",
+    "testing",
+    "ai",
+    "agents",
+    "evaluation",
+    "openai",
+    "anthropic",
+    "azure",
+    "red-team",
+    "security"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc --emitDeclarationOnly && bun build ./src/index.ts --outdir ./dist --target bun",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.39.0",
+    "zod": "^3.22.0",
+    "yaml": "^2.3.0",
+    "fastest-levenshtein": "^1.0.16",
+    "nanoid": "^5.0.0",
+    "pino": "^8.17.0",
+    "prom-client": "^15.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0",
+    "pino-pretty": "^10.3.0",
+    "typescript": "^5.3.0"
+  }
+}

package/src/adapters/factory.ts

@@ -0,0 +1,75 @@
+/**
+ * Adapter factory for creating model clients
+ */
+
+import { ArtemisError } from '../utils/errors';
+import { adapterRegistry, registerBuiltInAdapters } from './registry';
+import type { AdapterConfig, ModelClient, ProviderType } from './types';
+
+let initialized = false;
+
+/**
+ * Create a model adapter from configuration
+ */
+export async function createAdapter(config: AdapterConfig): Promise<ModelClient> {
+  // Only try to register built-in adapters if none are registered yet
+  // This allows CLI or other consumers to register adapters before calling createAdapter
+  if (!initialized && adapterRegistry.list().length === 0) {
+    try {
+      await registerBuiltInAdapters();
+    } catch {
+      // Ignore errors - adapters may be registered externally
+    }
+    initialized = true;
+  }
+
+  if (adapterRegistry.isUnavailable(config.provider)) {
+    const reason = adapterRegistry.getUnavailableReason(config.provider);
+    throw new ArtemisError(
+      `Provider '${config.provider}' is not yet available. ${reason} ` +
+        `Available providers: ${adapterRegistry.list().join(', ')}`,
+      'PROVIDER_UNAVAILABLE'
+    );
+  }
+
+  const factory = adapterRegistry.get(config.provider);
+
+  if (!factory) {
+    const available = adapterRegistry.list().join(', ');
+    const unavailable = adapterRegistry
+      .listUnavailable()
+      .map((u) => u.provider)
+      .join(', ');
+    throw new ArtemisError(
+      `Unknown provider: ${config.provider}. ` +
+        `Available: ${available || 'none'}. ` +
+        `Coming soon: ${unavailable || 'none'}`,
+      'UNKNOWN_PROVIDER'
+    );
+  }
+
+  return factory(config);
+}
+
+/**
+ * Register a custom adapter
+ */
+export function registerAdapter(
+  provider: ProviderType | string,
+  factory: (config: AdapterConfig) => Promise<ModelClient>
+): void {
+  adapterRegistry.register(provider as ProviderType, factory);
+}
+
+/**
+ * List available adapters
+ */
+export function listAdapters(): {
+  available: string[];
+  unavailable: { provider: string; reason: string }[];
+} {
+  return {
+    available: adapterRegistry.list(),
+    unavailable: adapterRegistry.listUnavailable(),
+  };
+}

package/src/adapters/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Adapter module exports
+ */
+
+export * from './types';
+export * from './factory';
+export * from './registry';

package/src/adapters/registry.ts

@@ -0,0 +1,143 @@
+/**
+ * Adapter registry for dynamic adapter management
+ */
+
+import type { AdapterConfig, ModelClient, ProviderType } from './types';
+
+type AdapterFactory = (config: AdapterConfig) => Promise<ModelClient>;
+
+interface UnavailableInfo {
+  provider: ProviderType;
+  reason: string;
+}
+
+/**
+ * Registry for adapter factories
+ */
+class AdapterRegistry {
+  private adapters: Map<ProviderType, AdapterFactory> = new Map();
+  private unavailableProviders: Map<ProviderType, string> = new Map();
+
+  /**
+   * Register an adapter factory for a provider type
+   */
+  register(provider: ProviderType, factory: AdapterFactory): void {
+    this.adapters.set(provider, factory);
+    this.unavailableProviders.delete(provider);
+  }
+
+  /**
+   * Mark a provider as unavailable (post-MVP)
+   */
+  markUnavailable(provider: ProviderType, reason: string): void {
+    this.unavailableProviders.set(provider, reason);
+  }
+
+  /**
+   * Get an adapter factory by provider type
+   */
+  get(provider: ProviderType): AdapterFactory | undefined {
+    return this.adapters.get(provider);
+  }
+
+  /**
+   * Check if a provider is registered
+   */
+  has(provider: ProviderType): boolean {
+    return this.adapters.has(provider);
+  }
+
+  /**
+   * Check if a provider is marked as unavailable
+   */
+  isUnavailable(provider: ProviderType): boolean {
+    return this.unavailableProviders.has(provider);
+  }
+
+  /**
+   * Get the reason why a provider is unavailable
+   */
+  getUnavailableReason(provider: ProviderType): string | undefined {
+    return this.unavailableProviders.get(provider);
+  }
+
+  /**
+   * List all registered providers
+   */
+  list(): ProviderType[] {
+    return Array.from(this.adapters.keys());
+  }
+
+  /**
+   * List unavailable providers with reasons
+   */
+  listUnavailable(): UnavailableInfo[] {
+    return Array.from(this.unavailableProviders.entries()).map(([provider, reason]) => ({
+      provider,
+      reason,
+    }));
+  }
+}
+
+export const adapterRegistry = new AdapterRegistry();
+
+/**
+ * Dynamically import a module with error handling
+ */
+async function tryImport<T>(moduleName: string): Promise<T> {
+  try {
+    return await import(/* @vite-ignore */ moduleName);
+  } catch (error) {
+    throw new Error(
+      `Failed to load adapter module '${moduleName}'. ` +
+        `Make sure it's installed: bun add ${moduleName}`
+    );
+  }
+}
+
+/**
+ * Register built-in adapters
+ * Adapters are loaded lazily when first requested
+ */
+export async function registerBuiltInAdapters(): Promise<void> {
+  // ============================================
+  // MVP ADAPTERS - Fully implemented
+  // ============================================
+
+  adapterRegistry.register('openai', async (config) => {
+    const mod = await tryImport<{ OpenAIAdapter: new (c: AdapterConfig) => ModelClient }>(
+      '@artemiskit/adapter-openai'
+    );
+    return new mod.OpenAIAdapter(config);
+  });
+
+  adapterRegistry.register('azure-openai', async (config) => {
+    const mod = await tryImport<{ OpenAIAdapter: new (c: AdapterConfig) => ModelClient }>(
+      '@artemiskit/adapter-openai'
+    );
+    return new mod.OpenAIAdapter(config);
+  });
+
+  adapterRegistry.register('vercel-ai', async (config) => {
+    const mod = await tryImport<{ VercelAIAdapter: new (c: AdapterConfig) => ModelClient }>(
+      '@artemiskit/adapter-vercel-ai'
+    );
+    return new mod.VercelAIAdapter(config);
+  });
+
+  adapterRegistry.register('anthropic', async (config) => {
+    const mod = await tryImport<{ AnthropicAdapter: new (c: AdapterConfig) => ModelClient }>(
+      '@artemiskit/adapter-anthropic'
+    );
+    return new mod.AnthropicAdapter(config);
+  });
+
+  // ============================================
+  // POST-MVP ADAPTERS - Not yet available
+  // ============================================
+  adapterRegistry.markUnavailable('google', 'Google adapter coming in v0.3.0');
+  adapterRegistry.markUnavailable('mistral', 'Mistral adapter coming in v0.3.0');
+  adapterRegistry.markUnavailable('ollama', 'Ollama adapter coming in v0.3.0');
+  adapterRegistry.markUnavailable('huggingface', 'Hugging Face adapter coming in v0.4.0');
+  adapterRegistry.markUnavailable('cohere', 'Cohere adapter coming in v0.4.0');
+}