@bonginkan/maria
Version:
MARIA OS v5.9.5 – Self-Evolving Organizational Intelligence OS | Speed Improvement Phase 3: LLM Optimization + Command Refactoring | Performance Measurement + Run Evidence System | Zero ESLint/TypeScript Errors | 人とAIが役割を持ち、学び、進化し続けるための仕事のOS | GraphRAG ×
242 lines (241 loc) • 7.08 kB
TypeScript
/**
* Memory Portability Framework
* Phase 4.0 Week 1: Enhanced memory export/import with enterprise security
* Integrates with existing Phase 4 components for complete data portability
*/
import { EventEmitter } from "node:events";
import type { EnterpriseDataPorter } from "./enterprise-data-porter";
import type { FormatHandlerRegistry } from "./formats/FormatHandlerRegistry";
import type { ValidationEngine } from "./validation/ValidationEngine";
import type { EnterpriseSecurityManager } from "./enterprise-security-manager";
import type { EnterpriseAuditLogger } from "./enterprise-audit-logger";
import type { AccessControlManager } from "../enterprise/access-control-manager";
import type { DualMemoryEngine } from "../dual-memory-engine";
export interface PortabilityConfig {
organizationId: string;
defaultFormat: "json" | "csv" | "parquet" | "xml";
enableEncryption: boolean;
enableCompression: boolean;
enableValidation: boolean;
auditExportImport: boolean;
maxExportSize: number;
allowedFormats: string[];
securityClassification: "public" | "internal" | "confidential" | "secret";
}
export interface ExportRequest {
userId: string;
sessionId: string;
format: string;
filter: MemoryFilter;
options: ExportOptions;
requestId: string;
timestamp: Date;
}
export interface MemoryFilter {
dateRange?: {
start: Date;
end: Date;
};
memoryTypes?: string[];
tags?: string[];
classification?: string[];
ownership?: "own" | "team" | "project" | "organization";
excludeFields?: string[];
}
export interface ExportOptions {
includeMetadata: boolean;
anonymizeData: boolean;
compressOutput: boolean;
encryptOutput: boolean;
splitLargeFiles: boolean;
maxFileSize: number;
outputPath?: string;
}
export interface ImportRequest {
userId: string;
sessionId: string;
filePath: string;
format: string;
options: ImportOptions;
requestId: string;
timestamp: Date;
}
export interface ImportOptions {
validateSchema: boolean;
skipDuplicates: boolean;
overwriteExisting: boolean;
preserveIds: boolean;
targetMemoryType?: string;
batchSize: number;
}
export interface PortabilityResult {
requestId: string;
success: boolean;
recordsProcessed: number;
recordsSkipped: number;
recordsErrors: number;
outputFiles?: string[];
errors?: PortabilityError[];
metadata: PortabilityMetadata;
duration: number;
}
export interface PortabilityError {
record: number;
field?: string;
error: string;
severity: "warning" | "error" | "critical";
}
export interface PortabilityMetadata {
exportId: string;
organizationId: string;
userId: string;
timestamp: Date;
format: string;
totalRecords: number;
dataClassification: string;
schema: unknown;
checksums: {
[algorithm: string]: string;
};
compression?: {
algorithm: string;
ratio: number;
};
encryption?: {
algorithm: string;
keyId: string;
};
}
export interface MigrationPlan {
id: string;
name: string;
description: string;
sourceSystem: string;
targetSystem: string;
mappings: FieldMapping[];
transformations: DataTransformation[];
validations: ValidationRule[];
schedule?: MigrationSchedule;
}
export interface FieldMapping {
sourceField: string;
targetField: string;
transformation?: string;
required: boolean;
defaultValue?: unknown;
}
export interface DataTransformation {
type: "rename" | "convert" | "calculate" | "filter" | "aggregate";
expression: string;
parameters: {
[key: string]: unknown;
};
}
export interface ValidationRule {
field: string;
type: "required" | "format" | "range" | "custom";
condition: string;
message: string;
}
export interface MigrationSchedule {
startTime: Date;
endTime?: Date;
batchSize: number;
interval: number;
maxConcurrentJobs: number;
}
/**
* Memory Portability Framework
* Orchestrates memory export/import operations with enterprise security
*/
export declare class MemoryPortabilityFramework extends EventEmitter {
private config;
private dataPorter;
private formatRegistry;
private validationEngine;
private securityManager;
private auditLogger;
private accessControl;
private memoryEngine;
private activeJobs;
private migrationPlans;
constructor(config: PortabilityConfig, dependencies: {
dataPorter: EnterpriseDataPorter;
formatRegistry: FormatHandlerRegistry;
validationEngine: ValidationEngine;
securityManager: EnterpriseSecurityManager;
auditLogger: EnterpriseAuditLogger;
accessControl: AccessControlManager;
memoryEngine: DualMemoryEngine;
});
/**
* Export memories with security and validation
*/
exportMemories(request: ExportRequest): Promise<PortabilityResult>;
/**
* Import memories with validation and conflict resolution
*/
importMemories(request: ImportRequest): Promise<PortabilityResult>;
/**
* Create and execute migration plan
*/
executeMigration(planId: string, userId: string): Promise<PortabilityResult>;
/**
* Get list of supported formats
*/
getSupportedFormats(): string[];
/**
* Get active portability jobs
*/
getActiveJobs(): PortabilityJob[];
/**
* Cancel a running job
*/
cancelJob(jobId: string): Promise<boolean>;
/**
* Private helper methods
*/
private initializeFramework;
private authorizeDataAccess;
private validateExportRequest;
private validateImportRequest;
private createExportJob;
private createImportJob;
private retrieveMemories;
private processMemoriesForExport;
private generateExportFiles;
private createExportMetadata;
private parseImportFile;
private processMemoriesForImport;
private storeImportedMemories;
private createFailureMetadata;
private createMigrationMetadata;
private estimateExportSize;
private anonymizeMemories;
private createDefaultMigrationPlans;
private cleanupCompletedJobs;
}
interface PortabilityJob {
id: string;
type: "export" | "import" | "migration";
status: "running" | "completed" | "failed" | "cancelled";
progress: number;
startTime: Date;
endTime?: Date;
request: ExportRequest | ImportRequest;
cancelled: boolean;
error?: string;
}
/**
* Factory function to create memory portability framework
*/
export declare function createMemoryPortabilityFramework(config: PortabilityConfig, dependencies: {
dataPorter: EnterpriseDataPorter;
formatRegistry: FormatHandlerRegistry;
validationEngine: ValidationEngine;
securityManager: EnterpriseSecurityManager;
auditLogger: EnterpriseAuditLogger;
accessControl: AccessControlManager;
memoryEngine: DualMemoryEngine;
}): MemoryPortabilityFramework;
export {};