monora-ai 2.0.0 → 2.1.3

package/dist/model.js

@@ -0,0 +1,371 @@
+"use strict";
+/**
+ * MonoraModel - Registered AI model/application with its specification.
+ *
+ * Provides the MonoraModel class for registering and managing AI models/applications
+ * being monitored by Monora.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValidationResult = createValidationResult;
+exports.validationResultToDict = validationResultToDict;
+exports.createMonoraModel = createMonoraModel;
+exports.modelFromData = modelFromData;
+exports.modelFromSpec = modelFromSpec;
+exports.validateEvent = validateEvent;
+exports.generateConfig = generateConfig;
+exports.modelToDict = modelToDict;
+exports.modelToJson = modelToJson;
+exports.modelFromDict = modelFromDict;
+exports.modelFromJson = modelFromJson;
+exports.saveModel = saveModel;
+exports.loadModel = loadModel;
+exports.saveSchemaContract = saveSchemaContract;
+exports.saveConfig = saveConfig;
+exports.modelToString = modelToString;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const spec_1 = require("./spec");
+const schemaInference_1 = require("./schemaInference");
+/**
+ * Create a ValidationResult.
+ */
+function createValidationResult(valid, errors = [], warnings = []) {
+    return { valid, errors, warnings };
+}
+/**
+ * Convert ValidationResult to dictionary.
+ */
+function validationResultToDict(result) {
+    return {
+        valid: result.valid,
+        errors: result.errors.map((e) => ({
+            field: e.field,
+            message: e.message,
+            expected: e.expected,
+            actual: e.actual,
+        })),
+        warnings: result.warnings,
+    };
+}
+/**
+ * Create a MonoraModel instance.
+ */
+function createMonoraModel(options) {
+    return {
+        modelId: options.modelId,
+        spec: options.spec,
+        riskCategory: options.riskCategory ?? 'limited',
+        intendedUse: options.intendedUse,
+        createdAt: new Date().toISOString(),
+        updatedAt: undefined,
+        tags: options.tags ?? [],
+        owner: options.owner,
+    };
+}
+/**
+ * Create a MonoraModel from sample data using schema inference.
+ *
+ * This is the primary way to create a model when you have sample events.
+ * It analyzes the events to infer the schema, detect PII, and configure
+ * appropriate enrichments.
+ */
+function modelFromData(options) {
+    const { source, modelName = 'unnamed-model', modelVersion = '1.0.0', complianceTargets, riskCategory = 'limited', intendedUse, detectPii = true, sampleSize = 100, tags = [], owner, } = options;
+    // Load events if source is a path
+    let events;
+    if (typeof source === 'string') {
+        events = (0, schemaInference_1.loadEventsFromFile)(source);
+    }
+    else {
+        events = source;
+    }
+    // Infer schema
+    const spec = (0, schemaInference_1.inferSchemaFromEvents)(events, {
+        modelName,
+        modelVersion,
+        complianceTargets,
+        detectPii,
+        sampleSize,
+    });
+    return createMonoraModel({
+        modelId: modelName,
+        spec,
+        riskCategory,
+        intendedUse,
+        tags,
+        owner,
+    });
+}
+/**
+ * Create a MonoraModel from an existing MonoraSpec.
+ */
+function modelFromSpec(spec, options = {}) {
+    return createMonoraModel({
+        modelId: options.modelId || spec.modelName || 'unnamed-model',
+        spec,
+        riskCategory: options.riskCategory ?? 'limited',
+        intendedUse: options.intendedUse,
+        tags: options.tags ?? [],
+        owner: options.owner,
+    });
+}
+/**
+ * Flatten nested dictionary to dot-notation keys.
+ */
+function flattenDict(obj, parentKey = '', sep = '.') {
+    const items = [];
+    for (const [k, v] of Object.entries(obj)) {
+        const newKey = parentKey ? `${parentKey}${sep}${k}` : k;
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+            const nested = flattenDict(v, newKey, sep);
+            items.push(...Object.entries(nested));
+        }
+        else {
+            items.push([newKey, v]);
+        }
+    }
+    return Object.fromEntries(items);
+}
+/**
+ * Get Python type(s) for a FieldType.
+ */
+function getExpectedTypes(fieldType) {
+    const typeMapping = {
+        string: ['string'],
+        number: ['number'],
+        integer: ['number'],
+        boolean: ['boolean'],
+        array: ['array'],
+        object: ['object'],
+    };
+    return typeMapping[fieldType] || ['string'];
+}
+/**
+ * Check if a value matches the expected field type.
+ */
+function matchesType(value, fieldType) {
+    const expectedTypes = getExpectedTypes(fieldType);
+    if (expectedTypes.includes('string') && typeof value === 'string')
+        return true;
+    if (expectedTypes.includes('number') && typeof value === 'number')
+        return true;
+    if (expectedTypes.includes('boolean') && typeof value === 'boolean')
+        return true;
+    if (expectedTypes.includes('array') && Array.isArray(value))
+        return true;
+    if (expectedTypes.includes('object') && typeof value === 'object' && !Array.isArray(value))
+        return true;
+    return false;
+}
+/**
+ * Validate an event against a model's specification.
+ */
+function validateEvent(model, event) {
+    const errors = [];
+    const warnings = [];
+    // Flatten the event for field checking
+    const flatEvent = flattenDict(event);
+    const allFields = (0, spec_1.getAllFields)(model.spec);
+    // Check all required fields
+    for (const fieldSpec of allFields) {
+        if (fieldSpec.required) {
+            if (!(fieldSpec.name in flatEvent)) {
+                errors.push({
+                    field: fieldSpec.name,
+                    message: `Required field '${fieldSpec.name}' is missing`,
+                });
+            }
+            else if (flatEvent[fieldSpec.name] === null && !fieldSpec.nullable) {
+                errors.push({
+                    field: fieldSpec.name,
+                    message: `Field '${fieldSpec.name}' cannot be null`,
+                });
+            }
+        }
+    }
+    // Check field types
+    for (const fieldSpec of allFields) {
+        if (fieldSpec.name in flatEvent) {
+            const value = flatEvent[fieldSpec.name];
+            if (value !== null && value !== undefined) {
+                if (!matchesType(value, fieldSpec.dataType)) {
+                    errors.push({
+                        field: fieldSpec.name,
+                        message: `Field '${fieldSpec.name}' has wrong type`,
+                        expected: fieldSpec.dataType,
+                        actual: typeof value,
+                    });
+                }
+            }
+        }
+    }
+    // Check identifiers
+    for (const fieldSpec of model.spec.identifiers || []) {
+        if (!(fieldSpec.name in flatEvent)) {
+            warnings.push(`Identifier field '${fieldSpec.name}' is missing`);
+        }
+    }
+    return createValidationResult(errors.length === 0, errors, warnings);
+}
+/**
+ * Generate a complete Monora configuration from a model.
+ */
+function generateConfig(model) {
+    const config = (0, spec_1.specToConfig)(model.spec);
+    // Add model-specific configuration
+    config.defaults = config.defaults || {};
+    config.defaults.service_name = model.modelId;
+    // Add risk category for AI Act compliance
+    config.ai_act = config.ai_act || { enabled: true };
+    config.ai_act.default_risk_category = model.riskCategory;
+    // Add model metadata to onboarding section
+    config.onboarding = config.onboarding || { enabled: true };
+    config.onboarding.model_spec = {
+        name: model.modelId,
+        version: model.spec.modelVersion,
+        event_ts_field: model.spec.eventTimestampField,
+        risk_category: model.riskCategory,
+        intended_use: model.intendedUse,
+        roles: {
+            inputs: model.spec.inputs.map((f) => f.name),
+            outputs: model.spec.outputs.map((f) => f.name),
+            metadata: (model.spec.metadata || []).map((f) => f.name),
+            identifiers: (model.spec.identifiers || []).map((f) => f.name),
+        },
+    };
+    return config;
+}
+/**
+ * Convert MonoraModel to dictionary representation.
+ */
+function modelToDict(model) {
+    return {
+        model_id: model.modelId,
+        spec: (0, spec_1.specToDict)(model.spec),
+        risk_category: model.riskCategory,
+        intended_use: model.intendedUse,
+        created_at: model.createdAt,
+        updated_at: model.updatedAt,
+        tags: model.tags,
+        owner: model.owner,
+    };
+}
+/**
+ * Convert MonoraModel to JSON string.
+ */
+function modelToJson(model, indent = 2) {
+    return JSON.stringify(modelToDict(model), null, indent);
+}
+/**
+ * Create MonoraModel from dictionary representation.
+ */
+function modelFromDict(data) {
+    return {
+        modelId: data.model_id || data.modelId,
+        spec: (0, spec_1.specFromDict)(data.spec),
+        riskCategory: data.risk_category || data.riskCategory || 'limited',
+        intendedUse: data.intended_use || data.intendedUse,
+        createdAt: data.created_at || data.createdAt || new Date().toISOString(),
+        updatedAt: data.updated_at || data.updatedAt,
+        tags: data.tags || [],
+        owner: data.owner,
+    };
+}
+/**
+ * Create MonoraModel from JSON string.
+ */
+function modelFromJson(jsonStr) {
+    return modelFromDict(JSON.parse(jsonStr));
+}
+/**
+ * Save MonoraModel to a JSON file.
+ */
+function saveModel(model, filePath) {
+    const resolvedPath = path.resolve(filePath);
+    const dir = path.dirname(resolvedPath);
+    // Create directory if it doesn't exist
+    fs.mkdirSync(dir, { recursive: true });
+    // Update timestamp
+    model.updatedAt = new Date().toISOString();
+    fs.writeFileSync(resolvedPath, modelToJson(model), 'utf-8');
+}
+/**
+ * Load MonoraModel from a JSON file.
+ */
+function loadModel(filePath) {
+    const resolvedPath = path.resolve(filePath);
+    const content = fs.readFileSync(resolvedPath, 'utf-8');
+    return modelFromJson(content);
+}
+/**
+ * Save just the schema contract for use with onboarding validation.
+ */
+function saveSchemaContract(model, filePath) {
+    const contract = (0, spec_1.specToSchemaContract)(model.spec);
+    const resolvedPath = path.resolve(filePath);
+    const dir = path.dirname(resolvedPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(resolvedPath, JSON.stringify(contract, null, 2), 'utf-8');
+}
+/**
+ * Save the generated Monora configuration.
+ */
+function saveConfig(model, filePath, format = 'yaml') {
+    const config = generateConfig(model);
+    const resolvedPath = path.resolve(filePath);
+    const dir = path.dirname(resolvedPath);
+    fs.mkdirSync(dir, { recursive: true });
+    if (format === 'yaml') {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const yaml = require('js-yaml');
+            fs.writeFileSync(resolvedPath, yaml.dump(config, { sortKeys: false }), 'utf-8');
+        }
+        catch {
+            // Fall back to JSON if js-yaml not available
+            fs.writeFileSync(resolvedPath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+    }
+    else {
+        fs.writeFileSync(resolvedPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+}
+/**
+ * Get a string representation of a MonoraModel.
+ */
+function modelToString(model) {
+    return `MonoraModel(modelId='${model.modelId}', riskCategory='${model.riskCategory}', inputs=${model.spec.inputs.length}, outputs=${model.spec.outputs.length})`;
+}

package/dist/onboarding.d.ts

@@ -0,0 +1,42 @@
+import { MonoraConfig } from './config';
+export interface BuildModelSpecOptions {
+    name?: string;
+    version?: string;
+    eventTsField?: string;
+    schemaRef?: string;
+    roles?: {
+        inputs?: string[];
+        outputs?: string[];
+        metadata?: string[];
+        identifiers?: string[];
+    };
+}
+export interface OnboardingResult {
+    status: string;
+    errors: string[];
+    warnings: string[];
+    coverage: Record<string, any>;
+    artifacts: Record<string, any>;
+}
+export interface ValidateOnboardingOptions {
+    configPath?: string;
+    configDict?: MonoraConfig;
+    inputPathOverride?: string;
+    persist?: boolean;
+}
+export interface CompleteOnboardingOptions {
+    configPath?: string;
+    configDict?: MonoraConfig;
+    completedBy?: string;
+}
+export declare function buildModelSpec(options?: BuildModelSpecOptions): Record<string, any>;
+export declare function validateOnboarding(options?: ValidateOnboardingOptions): OnboardingResult;
+export declare function completeOnboarding(options?: CompleteOnboardingOptions): OnboardingResult;
+export declare function getOnboardingStatus(options?: {
+    configPath?: string;
+    configDict?: MonoraConfig;
+}): Record<string, any>;
+export declare function resolveEnrichmentPlan(config: MonoraConfig, options?: {
+    apply?: boolean;
+}): Record<string, any>;
+//# sourceMappingURL=onboarding.d.ts.map

package/dist/onboarding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding.d.ts","sourceRoot":"","sources":["../src/onboarding.ts"],"names":[],"mappings":"AAIA,OAAO,EAA8B,YAAY,EAAE,MAAM,UAAU,CAAC;AAKpE,MAAM,WAAW,qBAAqB;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE;QACN,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;KACxB,CAAC;CACH;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,yBAAyB;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,yBAAyB;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,YAAY,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA+CD,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAcvF;AAED,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,yBAA8B,GAAG,gBAAgB,CA8I5F;AAED,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,yBAA8B,GAAG,gBAAgB,CAgH5F;AAED,wBAAgB,mBAAmB,CAAC,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,YAAY,CAAA;CAAO,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAsEzH;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAC5B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAkErB"}