monora-ai 2.0.0 → 2.1.3

package/dist/schemaInference.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Schema Inference - Automatically infer MonoraSpec from sample events.
+ *
+ * Analyzes sample LLM events and generates a MonoraSpec with field definitions,
+ * role assignments, and PII detection.
+ */
+import { FieldType, FieldRole, PIIType, MonoraSpec } from './spec';
+/**
+ * Detect the most likely field type from sample values.
+ */
+export declare function detectFieldType(values: any[]): FieldType;
+/**
+ * Detect if a field contains PII based on field name and content.
+ */
+export declare function detectPiiType(fieldName: string, values: any[], checkContent?: boolean): PIIType | undefined;
+/**
+ * Suggest a role (input/output/metadata/identifier) for a field.
+ */
+export declare function suggestRole(fieldName: string, fieldType: FieldType): FieldRole;
+/**
+ * Detect which field is most likely the event timestamp.
+ */
+export declare function detectTimestampField(fieldNames: string[]): string | undefined;
+/**
+ * Flatten a nested object into dot-notation keys.
+ */
+export declare function flattenDict(obj: Record<string, any>, parentKey?: string, sep?: string): Record<string, any>;
+/**
+ * Collect sample values for each field across events.
+ */
+export declare function collectFieldValues(events: Array<Record<string, any>>, sampleSize?: number): Map<string, any[]>;
+/**
+ * Compute statistics for a field's values.
+ */
+export declare function computeFieldStats(values: any[]): Record<string, any>;
+export interface InferSchemaOptions {
+    /** Name for the model/application */
+    modelName?: string;
+    /** Version string */
+    modelVersion?: string;
+    /** Compliance frameworks to target */
+    complianceTargets?: string[];
+    /** Whether to scan for PII */
+    detectPii?: boolean;
+    /** Maximum samples per field for analysis */
+    sampleSize?: number;
+}
+/**
+ * Infer a MonoraSpec from sample events.
+ *
+ * Analyzes the structure of sample events and automatically:
+ * - Detects field types (string, number, boolean, etc.)
+ * - Assigns roles (input, output, metadata, identifier)
+ * - Detects PII fields
+ * - Identifies the timestamp field
+ * - Suggests enrichments based on compliance targets
+ */
+export declare function inferSchemaFromEvents(events: Array<Record<string, any>>, options?: InferSchemaOptions): MonoraSpec;
+/**
+ * Load events from a JSONL file.
+ */
+export declare function loadEventsFromFile(filePath: string): Array<Record<string, any>>;
+/**
+ * Infer a MonoraSpec from a JSONL file.
+ */
+export declare function inferSchemaFromFile(filePath: string, options?: InferSchemaOptions): MonoraSpec;
+export interface InferenceReportField {
+    name: string;
+    inferred_type: string;
+    suggested_role: string;
+    pii_type: string | null;
+    stats: Record<string, any>;
+    sample_values: any[];
+}
+export interface InferenceReport {
+    event_count: number;
+    field_count: number;
+    timestamp_field: string | undefined;
+    fields: InferenceReportField[];
+    role_summary: {
+        inputs: number;
+        outputs: number;
+        metadata: number;
+        identifiers: number;
+    };
+    pii_fields: string[];
+}
+/**
+ * Generate a detailed report about inferred schema.
+ */
+export declare function generateInferenceReport(events: Array<Record<string, any>>, sampleSize?: number): InferenceReport;
+//# sourceMappingURL=schemaInference.d.ts.map

package/dist/schemaInference.d.ts.map

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

package/dist/schemaInference.js

@@ -0,0 +1,466 @@
+"use strict";
+/**
+ * Schema Inference - Automatically infer MonoraSpec from sample events.
+ *
+ * Analyzes sample LLM events and generates a MonoraSpec with field definitions,
+ * role assignments, and PII detection.
+ */
+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.detectFieldType = detectFieldType;
+exports.detectPiiType = detectPiiType;
+exports.suggestRole = suggestRole;
+exports.detectTimestampField = detectTimestampField;
+exports.flattenDict = flattenDict;
+exports.collectFieldValues = collectFieldValues;
+exports.computeFieldStats = computeFieldStats;
+exports.inferSchemaFromEvents = inferSchemaFromEvents;
+exports.loadEventsFromFile = loadEventsFromFile;
+exports.inferSchemaFromFile = inferSchemaFromFile;
+exports.generateInferenceReport = generateInferenceReport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const spec_1 = require("./spec");
+/** Patterns for detecting input fields */
+const INPUT_FIELD_PATTERNS = [
+    /.*prompt.*/i,
+    /.*query.*/i,
+    /.*question.*/i,
+    /.*input.*/i,
+    /.*message.*/i,
+    /.*request.*/i,
+    /.*user_input.*/i,
+    /.*context.*/i,
+    /.*instruction.*/i,
+    /.*system.*/i,
+];
+/** Patterns for detecting output fields */
+const OUTPUT_FIELD_PATTERNS = [
+    /.*response.*/i,
+    /.*answer.*/i,
+    /.*output.*/i,
+    /.*completion.*/i,
+    /.*result.*/i,
+    /.*reply.*/i,
+    /.*generated.*/i,
+    /.*content.*/i,
+    /.*text.*/i,
+];
+/** Patterns for detecting identifier fields */
+const IDENTIFIER_FIELD_PATTERNS = [
+    /.*_id$/i,
+    /^id$/i,
+    /.*event_id.*/i,
+    /.*trace_id.*/i,
+    /.*span_id.*/i,
+    /.*request_id.*/i,
+    /.*session_id.*/i,
+    /.*correlation_id.*/i,
+    /.*uuid.*/i,
+];
+/** Patterns for detecting timestamp fields */
+const TIMESTAMP_FIELD_PATTERNS = [
+    /.*timestamp.*/i,
+    /.*time.*/i,
+    /.*created_at.*/i,
+    /.*updated_at.*/i,
+    /.*date.*/i,
+    /.*_at$/i,
+];
+/** PII detection patterns */
+const PII_PATTERNS = new Map([
+    ['email', /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/],
+    ['phone', /\+?[\d\s\-\(\)]{10,}/],
+    ['ssn', /\d{3}-?\d{2}-?\d{4}/],
+    ['credit_card', /\d{4}[\s\-]?\d{4}[\s\-]?\d{4}[\s\-]?\d{4}/],
+    ['ip_address', /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/],
+]);
+/** PII field name hints */
+const PII_FIELD_NAME_HINTS = new Map([
+    ['email', ['email', 'e_mail', 'mail', 'email_address']],
+    ['phone', ['phone', 'telephone', 'mobile', 'cell', 'phone_number']],
+    ['ssn', ['ssn', 'social_security', 'tax_id']],
+    ['credit_card', ['card', 'credit_card', 'cc_number', 'card_number']],
+    ['name', ['name', 'first_name', 'last_name', 'full_name', 'user_name', 'username']],
+    ['address', ['address', 'street', 'city', 'zip', 'postal', 'location']],
+    ['ip_address', ['ip', 'ip_address', 'client_ip', 'remote_ip']],
+    ['date_of_birth', ['dob', 'date_of_birth', 'birth_date', 'birthday']],
+]);
+/**
+ * Detect the most likely field type from sample values.
+ */
+function detectFieldType(values) {
+    if (!values || values.length === 0) {
+        return 'string';
+    }
+    const nonNullValues = values.filter((v) => v !== null && v !== undefined);
+    if (nonNullValues.length === 0) {
+        return 'string';
+    }
+    const typeCounts = new Map();
+    for (const value of nonNullValues) {
+        let fieldType;
+        if (typeof value === 'boolean') {
+            fieldType = 'boolean';
+        }
+        else if (Number.isInteger(value)) {
+            fieldType = 'integer';
+        }
+        else if (typeof value === 'number') {
+            fieldType = 'number';
+        }
+        else if (typeof value === 'string') {
+            fieldType = 'string';
+        }
+        else if (Array.isArray(value)) {
+            fieldType = 'array';
+        }
+        else if (typeof value === 'object') {
+            fieldType = 'object';
+        }
+        else {
+            fieldType = 'string';
+        }
+        typeCounts.set(fieldType, (typeCounts.get(fieldType) || 0) + 1);
+    }
+    // Return the most common type
+    let maxType = 'string';
+    let maxCount = 0;
+    for (const [type, count] of typeCounts) {
+        if (count > maxCount) {
+            maxCount = count;
+            maxType = type;
+        }
+    }
+    return maxType;
+}
+/**
+ * Detect if a field contains PII based on field name and content.
+ */
+function detectPiiType(fieldName, values, checkContent = true) {
+    const fieldNameLower = fieldName.toLowerCase();
+    // Check field name hints first (faster)
+    for (const [piiType, hints] of PII_FIELD_NAME_HINTS) {
+        for (const hint of hints) {
+            if (fieldNameLower.includes(hint)) {
+                return piiType;
+            }
+        }
+    }
+    // Check content patterns if enabled
+    if (checkContent) {
+        const stringValues = values
+            .filter((v) => v !== null && v !== undefined)
+            .map((v) => String(v))
+            .slice(0, 10); // Check first 10 values
+        for (const [piiType, pattern] of PII_PATTERNS) {
+            for (const value of stringValues) {
+                if (pattern.test(value)) {
+                    return piiType;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Suggest a role (input/output/metadata/identifier) for a field.
+ */
+function suggestRole(fieldName, fieldType) {
+    const fieldNameLower = fieldName.toLowerCase();
+    // Check identifier patterns first (highest priority)
+    for (const pattern of IDENTIFIER_FIELD_PATTERNS) {
+        if (pattern.test(fieldNameLower)) {
+            return 'identifier';
+        }
+    }
+    // Check input patterns
+    for (const pattern of INPUT_FIELD_PATTERNS) {
+        if (pattern.test(fieldNameLower)) {
+            return 'input';
+        }
+    }
+    // Check output patterns
+    for (const pattern of OUTPUT_FIELD_PATTERNS) {
+        if (pattern.test(fieldNameLower)) {
+            return 'output';
+        }
+    }
+    // Default to metadata
+    return 'metadata';
+}
+/**
+ * Detect which field is most likely the event timestamp.
+ */
+function detectTimestampField(fieldNames) {
+    for (const pattern of TIMESTAMP_FIELD_PATTERNS) {
+        for (const name of fieldNames) {
+            if (pattern.test(name.toLowerCase())) {
+                return name;
+            }
+        }
+    }
+    // Check for common exact names
+    const commonNames = ['timestamp', 'time', 'created_at', 'event_time', 'ts'];
+    for (const name of fieldNames) {
+        if (commonNames.includes(name.toLowerCase())) {
+            return name;
+        }
+    }
+    return undefined;
+}
+/**
+ * Flatten a nested object into 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);
+}
+/**
+ * Collect sample values for each field across events.
+ */
+function collectFieldValues(events, sampleSize = 100) {
+    const fieldValues = new Map();
+    const eventsToProcess = events.slice(0, sampleSize * 10);
+    for (const event of eventsToProcess) {
+        const flat = flattenDict(event);
+        for (const [key, value] of Object.entries(flat)) {
+            const values = fieldValues.get(key) || [];
+            if (values.length < sampleSize) {
+                values.push(value);
+                fieldValues.set(key, values);
+            }
+        }
+    }
+    return fieldValues;
+}
+/**
+ * Compute statistics for a field's values.
+ */
+function computeFieldStats(values) {
+    const nonNull = values.filter((v) => v !== null && v !== undefined);
+    const stats = {
+        total_count: values.length,
+        non_null_count: nonNull.length,
+        null_count: values.length - nonNull.length,
+        presence_ratio: values.length > 0 ? nonNull.length / values.length : 0,
+    };
+    // Type-specific stats
+    if (nonNull.length > 0) {
+        const firstVal = nonNull[0];
+        if (typeof firstVal === 'number') {
+            const numericVals = nonNull.filter((v) => typeof v === 'number');
+            if (numericVals.length > 0) {
+                stats.min = Math.min(...numericVals);
+                stats.max = Math.max(...numericVals);
+                stats.avg = numericVals.reduce((a, b) => a + b, 0) / numericVals.length;
+            }
+        }
+        else if (typeof firstVal === 'string') {
+            const stringVals = nonNull.filter((v) => typeof v === 'string');
+            if (stringVals.length > 0) {
+                const lengths = stringVals.map((s) => s.length);
+                stats.min_length = Math.min(...lengths);
+                stats.max_length = Math.max(...lengths);
+                stats.avg_length = lengths.reduce((a, b) => a + b, 0) / lengths.length;
+            }
+        }
+    }
+    return stats;
+}
+/**
+ * Infer a MonoraSpec from sample events.
+ *
+ * Analyzes the structure of sample events and automatically:
+ * - Detects field types (string, number, boolean, etc.)
+ * - Assigns roles (input, output, metadata, identifier)
+ * - Detects PII fields
+ * - Identifies the timestamp field
+ * - Suggests enrichments based on compliance targets
+ */
+function inferSchemaFromEvents(events, options = {}) {
+    const { modelName, modelVersion = '1.0.0', complianceTargets = [], detectPii = true, sampleSize = 100, } = options;
+    if (!events || events.length === 0) {
+        throw new Error('Cannot infer schema from empty events list');
+    }
+    // Collect field values
+    const fieldValues = collectFieldValues(events, sampleSize);
+    // Detect timestamp field
+    const timestampField = detectTimestampField(Array.from(fieldValues.keys()));
+    // Analyze each field
+    const inputs = [];
+    const outputs = [];
+    const metadata = [];
+    const identifiers = [];
+    for (const [fieldName, values] of fieldValues) {
+        // Detect type
+        const fieldType = detectFieldType(values);
+        // Detect PII
+        let piiType;
+        if (detectPii) {
+            piiType = detectPiiType(fieldName, values);
+        }
+        // Compute stats
+        const stats = computeFieldStats(values);
+        // Create field spec
+        const fieldSpec = (0, spec_1.createFieldSpec)(fieldName, fieldType, {
+            required: stats.presence_ratio > 0.95,
+            nullable: stats.null_count > 0,
+            piiType,
+        });
+        // Assign role
+        const role = suggestRole(fieldName, fieldType);
+        switch (role) {
+            case 'input':
+                inputs.push(fieldSpec);
+                break;
+            case 'output':
+                outputs.push(fieldSpec);
+                break;
+            case 'identifier':
+                identifiers.push(fieldSpec);
+                break;
+            default:
+                metadata.push(fieldSpec);
+        }
+    }
+    // Build enrichment config from compliance targets
+    let enrichments = (0, spec_1.createEnrichmentConfig)();
+    if (complianceTargets.length > 0) {
+        for (const framework of complianceTargets) {
+            const frameworkConfig = (0, spec_1.enrichmentConfigForFramework)(framework);
+            enrichments = (0, spec_1.mergeEnrichmentConfigs)(enrichments, frameworkConfig);
+        }
+    }
+    return (0, spec_1.createMonoraSpec)({
+        inputs,
+        outputs,
+        metadata,
+        identifiers,
+        enrichments,
+        complianceTargets,
+        modelName,
+        modelVersion,
+        eventTimestampField: timestampField || 'timestamp',
+    });
+}
+/**
+ * Load events from a JSONL file.
+ */
+function loadEventsFromFile(filePath) {
+    const events = [];
+    const resolvedPath = path.resolve(filePath);
+    const content = fs.readFileSync(resolvedPath, 'utf-8');
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) {
+            try {
+                events.push(JSON.parse(trimmed));
+            }
+            catch {
+                // Skip invalid JSON lines
+                continue;
+            }
+        }
+    }
+    return events;
+}
+/**
+ * Infer a MonoraSpec from a JSONL file.
+ */
+function inferSchemaFromFile(filePath, options = {}) {
+    const events = loadEventsFromFile(filePath);
+    return inferSchemaFromEvents(events, options);
+}
+/**
+ * Generate a detailed report about inferred schema.
+ */
+function generateInferenceReport(events, sampleSize = 100) {
+    const fieldValues = collectFieldValues(events, sampleSize);
+    const fieldsReport = [];
+    const roleCounts = { inputs: 0, outputs: 0, metadata: 0, identifiers: 0 };
+    const piiFields = [];
+    for (const [fieldName, values] of fieldValues) {
+        const fieldType = detectFieldType(values);
+        const piiType = detectPiiType(fieldName, values);
+        const role = suggestRole(fieldName, fieldType);
+        const stats = computeFieldStats(values);
+        fieldsReport.push({
+            name: fieldName,
+            inferred_type: fieldType,
+            suggested_role: role,
+            pii_type: piiType || null,
+            stats,
+            sample_values: values.slice(0, 5),
+        });
+        // Update role counts
+        switch (role) {
+            case 'input':
+                roleCounts.inputs++;
+                break;
+            case 'output':
+                roleCounts.outputs++;
+                break;
+            case 'identifier':
+                roleCounts.identifiers++;
+                break;
+            default:
+                roleCounts.metadata++;
+        }
+        if (piiType) {
+            piiFields.push(fieldName);
+        }
+    }
+    const timestampField = detectTimestampField(Array.from(fieldValues.keys()));
+    return {
+        event_count: events.length,
+        field_count: fieldValues.size,
+        timestamp_field: timestampField,
+        fields: fieldsReport,
+        role_summary: roleCounts,
+        pii_fields: piiFields,
+    };
+}

package/dist/schema_validation.js

@@ -41,8 +41,8 @@ exports.validateTrustSummarySchema = validateTrustSummarySchema;
 exports.validateConfigSchema = validateConfigSchema;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const ajv_1 = __importDefault(require("ajv"));
-const ajv = new ajv_1.default({ allErrors: true, strict: false });
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const ajv = new _2020_1.default({ allErrors: true, strict: false });
 const schemaDir = path.join(__dirname, 'schemas');
 function loadSchema(name) {
     const schemaPath = path.join(schemaDir, name);