@bonginkan/maria 2.0.7 → 2.1.2

package/dist/index.d.ts

@@ -2,70 +2,11 @@ export { createCLI } from './cli.js';
 import { EventEmitter } from 'events';
 import 'commander';
 
-interface ConversationMessage {
-    id: string;
-    role: 'user' | 'assistant' | 'system';
-    content: string;
-    timestamp: Date;
-    model?: string;
-    tokensUsed?: number;
-    metadata?: Record<string, unknown>;
-}
-interface ConversationContext {
-    id: string;
-    messages: ConversationMessage[];
-    sessionId: string;
-    userId?: string;
-    startTime: Date;
-    lastActivity: Date;
-    config: ConversationConfig;
-    preferences?: UserPreferences;
-    history?: ConversationHistory[];
-    currentTask?: string;
-    hasErrors?: boolean;
-    isUrgent?: boolean;
-    isInteractive?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface ConversationHistory {
-    timestamp: Date;
-    action: string;
-    data?: Record<string, unknown>;
-}
-interface UserPreferences {
-    mode?: 'chat' | 'research' | 'command' | 'creative';
-    defaultModel?: string;
-    temperature?: number;
-    maxTokens?: number;
-    autoSave?: boolean;
-    language?: string;
-    theme?: 'light' | 'dark' | 'auto';
-    verbosity?: 'normal' | 'verbose' | 'quiet';
-    autoMode?: boolean;
-}
-interface ConversationConfig {
-    model: string;
-    maxTokens?: number;
-    temperature?: number;
-    stream?: boolean;
-    systemPrompt?: string;
-    tools?: string[];
-    safetySettings?: SafetySettings;
-}
-interface SafetySettings {
-    enableContentFilter: boolean;
-    restrictedTopics: string[];
-    maxPromptLength: number;
-    allowFileAccess: boolean;
-    allowNetworkAccess: boolean;
-}
-
 /**
  * Slash Command Type Definitions
  * Core types for the microservice-based command architecture
  */
-
-type CommandCategory = 'auth' | 'config' | 'project' | 'development' | 'media' | 'conversation' | 'advanced' | 'system';
+type CommandCategory = 'core' | 'auth' | 'config' | 'configuration' | 'project' | 'development' | 'generation' | 'analysis' | 'media' | 'conversation' | 'utilities' | 'integration' | 'advanced' | 'system';
 interface CommandArgs {
     raw: string[];
     parsed: Record<string, unknown>;
@@ -73,21 +14,20 @@ interface CommandArgs {
     options: Record<string, string>;
 }
 interface CommandContext {
-    conversation: ConversationContext;
     user?: {
         id: string;
         email?: string;
         role?: string;
-    };
+    } | null;
     session: {
         id: string;
-        startTime: Date;
         commandHistory: string[];
     };
+    conversation?: {
+        history: any[];
+    };
     environment: {
         cwd: string;
-        platform: string;
-        nodeVersion: string;
     };
 }
 interface CommandResult {
@@ -181,7 +121,7 @@ declare abstract class BaseCommand implements ISlashCommand {
     /**
      * Validate command arguments
      */
-    validate(args: CommandArgs): Promise<ValidationResult>;
+    validate(_args: CommandArgs): Promise<ValidationResult>;
     /**
      * Execute the command - must be implemented by subclasses
      */
@@ -300,7 +240,7 @@ declare const commandRegistry: CommandRegistry;
  */
 declare function initializeSlashCommands(): Promise<void>;
 /**
- * Get command suggestions for auto-complete with fuzzy matching
+ * Get command suggestions for auto-complete
  */
 declare function getCommandSuggestions(input: string): string[];
 /**
@@ -821,6 +761,163 @@ interface PerformanceConfig {
     batchSize: number;
     timeout: number;
     memoryLimit: number;
+    targetLatency?: number;
+}
+
+/**
+ * MARIA Memory System - System 1 Memory Implementation
+ *
+ * Fast, intuitive memory patterns for immediate responses
+ * Handles programming concepts, code patterns, and user preferences
+ */
+
+declare class System1MemoryManager implements System1Memory {
+    private knowledgeNodes;
+    userPreferences: UserPreferenceSet;
+    private conceptGraph;
+    private interactionHistory;
+    private patternLibrary;
+    private config;
+    private cache;
+    private lastAccessTimes;
+    constructor(config: System1Config);
+    get programmingConcepts(): KnowledgeNode[];
+    get businessLogic(): ConceptGraph;
+    get pastInteractions(): InteractionHistory;
+    get codePatterns(): PatternLibrary;
+    addKnowledgeNode(type: KnowledgeNode['type'], name: string, content: string, embedding: number[], metadata?: Partial<NodeMetadata>): Promise<KnowledgeNode>;
+    getKnowledgeNode(id: string): Promise<KnowledgeNode | null>;
+    searchKnowledgeNodes(query: string, queryEmbedding: number[], limit?: number): Promise<KnowledgeNode[]>;
+    updateKnowledgeNode(id: string, updates: Partial<KnowledgeNode>): Promise<boolean>;
+    addConceptEdge(sourceId: string, targetId: string, type: ConceptEdge['type'], weight?: number, confidence?: number): Promise<ConceptEdge>;
+    getRelatedConcepts(nodeId: string, maxDepth?: number): Promise<KnowledgeNode[]>;
+    addCodePattern(pattern: Omit<CodePattern, 'id'>): Promise<CodePattern>;
+    findCodePatterns(language?: string, framework?: string, useCase?: string, limit?: number): Promise<CodePattern[]>;
+    addAntiPattern(antiPattern: Omit<AntiPattern, 'id'>): Promise<AntiPattern>;
+    detectAntiPatterns(code: string): Promise<AntiPattern[]>;
+    recordSession(session: SessionRecord): Promise<void>;
+    updateCommandHistory(command: string): Promise<void>;
+    getFrequentCommands(limit?: number): Promise<CommandHistory[]>;
+    getRecentCommands(limit?: number): Promise<CommandHistory[]>;
+    updateUserPreferences(updates: Partial<UserPreferenceSet>): Promise<void>;
+    getUserPreference<K extends keyof UserPreferenceSet>(key: K): Promise<UserPreferenceSet[K]>;
+    processMemoryEvent(event: MemoryEvent): Promise<void>;
+    cleanupLeastUsedNodes(): Promise<void>;
+    compressMemory(): Promise<void>;
+    private generateNodeId;
+    private generatePatternId;
+    private calculateCosineSimilarity;
+    private applyAccessDecay;
+    private calculateUsageScore;
+    private invalidateCache;
+    private detectUsagePatterns;
+    private processCodeGenerationEvent;
+    private processPatternRecognitionEvent;
+    private processLearningUpdateEvent;
+    private extractCodePatterns;
+    private adaptUserPreferences;
+    private mergeimilarPatterns;
+    private calculatePatternSimilarity;
+    private mergePatterns;
+    private initializeDefaultPreferences;
+}
+
+/**
+ * MARIA Memory System - System 2 Memory Implementation
+ *
+ * Deliberate reasoning and quality traces for complex decision making
+ * Handles reasoning steps, quality evaluation, and improvement suggestions
+ */
+
+declare class System2MemoryManager implements System2Memory {
+    private reasoningTraces;
+    private qualityMetrics;
+    private decisionTrees;
+    private enhancements;
+    private reflectionEntries;
+    private config;
+    private analysisCache;
+    constructor(config: System2Config);
+    get reasoningSteps(): ReasoningTrace[];
+    get qualityEvaluation(): QualityMetrics;
+    get decisionContext(): DecisionTree;
+    get improvementSuggestions(): Enhancement[];
+    get reflectionData(): ReflectionEntry[];
+    startReasoningTrace(context: ReasoningContext, initialStep?: string): Promise<ReasoningTrace>;
+    addReasoningStep(traceId: string, stepData: Omit<ReasoningStep, 'id' | 'confidence' | 'duration' | 'dependencies'>): Promise<ReasoningStep>;
+    completeReasoningTrace(traceId: string, conclusion: string, confidence: number): Promise<ReasoningTrace>;
+    addAlternativeReasoning(traceId: string, alternative: Omit<AlternativeReasoning, 'id'>): Promise<AlternativeReasoning>;
+    getReasoningTrace(traceId: string): Promise<ReasoningTrace | null>;
+    searchReasoningTraces(query: {
+        domain?: string;
+        complexity?: string;
+        minQuality?: number;
+        timeframe?: {
+            start: Date;
+            end: Date;
+        };
+    }, limit?: number): Promise<ReasoningTrace[]>;
+    createDecisionTree(domain: string, initialCondition: string): Promise<DecisionTree>;
+    addDecisionNode(treeId: string, parentNodeId: string, node: Omit<DecisionNode, 'id'>): Promise<DecisionNode>;
+    addEvidence(treeId: string, nodeId: string, evidence: Evidence): Promise<void>;
+    queryDecisionTree(treeId: string, context: Record<string, unknown>): Promise<DecisionNode[]>;
+    proposeEnhancement(enhancement: Omit<Enhancement, 'id' | 'status'>): Promise<Enhancement>;
+    updateEnhancementStatus(enhancementId: string, status: Enhancement['status'], feedback?: string): Promise<boolean>;
+    getEnhancementsByType(type: Enhancement['type']): Promise<Enhancement[]>;
+    addReflectionEntry(trigger: string, observation: string, analysis: string, insight: string, confidence?: number): Promise<ReflectionEntry>;
+    addActionItem(reflectionId: string, actionItem: Omit<ActionItem, 'id' | 'status'>): Promise<ActionItem>;
+    getReflectionInsights(timeframe?: {
+        start: Date;
+        end: Date;
+    }, minConfidence?: number): Promise<ReflectionEntry[]>;
+    processMemoryEvent(event: MemoryEvent): Promise<void>;
+    assessCodeQuality(code: string, _language: string, context?: Record<string, unknown>): Promise<CodeQualityMetrics>;
+    updateQualityMetrics(metrics: Partial<QualityMetrics>): Promise<void>;
+    private generateTraceId;
+    private generateStepId;
+    private generateAlternativeId;
+    private generateDecisionTreeId;
+    private generateNodeId;
+    private generateEnhancementId;
+    private generateReflectionId;
+    private generateActionItemId;
+    private assessComplexity;
+    private identifyDomain;
+    private calculateStepConfidence;
+    private identifyDependencies;
+    private updateTraceQuality;
+    private calculateReasoningQuality;
+    private calculateCoherence;
+    private calculateCompleteness;
+    private calculateAccuracy;
+    private calculateEfficiency;
+    private calculateCreativity;
+    private generateImprovementSuggestions;
+    private updateGlobalQualityMetrics;
+    private createEmptyDecisionTree;
+    private findDecisionNode;
+    private calculateTreeComplexity;
+    private calculateNodeConfidence;
+    private traverseDecisionTree;
+    private evaluateCondition;
+    private shouldAutoApprove;
+    private evaluateEnhancementImpact;
+    private generateActionItems;
+    private processCodeGenerationEvent;
+    private processBugFixEvent;
+    private processQualityImprovementEvent;
+    private processGenericEvent;
+    private manageTraceLimit;
+    private calculateMaintainability;
+    private calculateReadability;
+    private calculateTestability;
+    private calculatePerformance;
+    private calculateSecurity;
+    private calculateBugDensity;
+    private calculateCyclomaticComplexity;
+    private calculateBasicComplexity;
+    private hashCode;
+    private initializeQualityMetrics;
 }
 
 /**
@@ -897,13 +994,23 @@ declare class DualMemoryEngine {
     private executeCombinedOperation;
     private combineResults;
     private generateCombinedSuggestions;
-    private processEvent;
+    processEvent(event: MemoryEvent): Promise<void>;
     private determineEventRouting;
     private adaptFromEvent;
     private startBackgroundProcessing;
     private processEventQueue;
     private cleanupCache;
     private optimizeMemory;
+    /**
+     * Get System 1 memory manager instance
+     * @returns System1MemoryManager instance
+     */
+    getSystem1(): System1MemoryManager;
+    /**
+     * Get System 2 memory manager instance
+     * @returns System2MemoryManager instance
+     */
+    getSystem2(): System2MemoryManager;
     private generateCacheKey;
     private isCacheValid;
     private updateOperationMetrics;
@@ -1064,162 +1171,6 @@ declare class MemoryCoordinator {
     destroy(): void;
 }
 
-/**
- * MARIA Memory System - System 1 Memory Implementation
- *
- * Fast, intuitive memory patterns for immediate responses
- * Handles programming concepts, code patterns, and user preferences
- */
-
-declare class System1MemoryManager implements System1Memory {
-    private knowledgeNodes;
-    userPreferences: UserPreferenceSet;
-    private conceptGraph;
-    private interactionHistory;
-    private patternLibrary;
-    private config;
-    private cache;
-    private lastAccessTimes;
-    constructor(config: System1Config);
-    get programmingConcepts(): KnowledgeNode[];
-    get businessLogic(): ConceptGraph;
-    get pastInteractions(): InteractionHistory;
-    get codePatterns(): PatternLibrary;
-    addKnowledgeNode(type: KnowledgeNode['type'], name: string, content: string, embedding: number[], metadata?: Partial<NodeMetadata>): Promise<KnowledgeNode>;
-    getKnowledgeNode(id: string): Promise<KnowledgeNode | null>;
-    searchKnowledgeNodes(query: string, queryEmbedding: number[], limit?: number): Promise<KnowledgeNode[]>;
-    updateKnowledgeNode(id: string, updates: Partial<KnowledgeNode>): Promise<boolean>;
-    addConceptEdge(sourceId: string, targetId: string, type: ConceptEdge['type'], weight?: number, confidence?: number): Promise<ConceptEdge>;
-    getRelatedConcepts(nodeId: string, maxDepth?: number): Promise<KnowledgeNode[]>;
-    addCodePattern(pattern: Omit<CodePattern, 'id'>): Promise<CodePattern>;
-    findCodePatterns(language?: string, framework?: string, useCase?: string, limit?: number): Promise<CodePattern[]>;
-    addAntiPattern(antiPattern: Omit<AntiPattern, 'id'>): Promise<AntiPattern>;
-    detectAntiPatterns(code: string): Promise<AntiPattern[]>;
-    recordSession(session: SessionRecord): Promise<void>;
-    updateCommandHistory(command: string): Promise<void>;
-    getFrequentCommands(limit?: number): Promise<CommandHistory[]>;
-    getRecentCommands(limit?: number): Promise<CommandHistory[]>;
-    updateUserPreferences(updates: Partial<UserPreferenceSet>): Promise<void>;
-    getUserPreference<K extends keyof UserPreferenceSet>(key: K): Promise<UserPreferenceSet[K]>;
-    processMemoryEvent(event: MemoryEvent): Promise<void>;
-    cleanupLeastUsedNodes(): Promise<void>;
-    compressMemory(): Promise<void>;
-    private generateNodeId;
-    private generatePatternId;
-    private calculateCosineSimilarity;
-    private applyAccessDecay;
-    private calculateUsageScore;
-    private invalidateCache;
-    private detectUsagePatterns;
-    private processCodeGenerationEvent;
-    private processPatternRecognitionEvent;
-    private processLearningUpdateEvent;
-    private extractCodePatterns;
-    private adaptUserPreferences;
-    private mergeimilarPatterns;
-    private calculatePatternSimilarity;
-    private mergePatterns;
-    private initializeDefaultPreferences;
-}
-
-/**
- * MARIA Memory System - System 2 Memory Implementation
- *
- * Deliberate reasoning and quality traces for complex decision making
- * Handles reasoning steps, quality evaluation, and improvement suggestions
- */
-
-declare class System2MemoryManager implements System2Memory {
-    private reasoningTraces;
-    private qualityMetrics;
-    private decisionTrees;
-    private enhancements;
-    private reflectionEntries;
-    private config;
-    private analysisCache;
-    constructor(config: System2Config);
-    get reasoningSteps(): ReasoningTrace[];
-    get qualityEvaluation(): QualityMetrics;
-    get decisionContext(): DecisionTree;
-    get improvementSuggestions(): Enhancement[];
-    get reflectionData(): ReflectionEntry[];
-    startReasoningTrace(context: ReasoningContext, initialStep?: string): Promise<ReasoningTrace>;
-    addReasoningStep(traceId: string, stepData: Omit<ReasoningStep, 'id' | 'confidence' | 'duration' | 'dependencies'>): Promise<ReasoningStep>;
-    completeReasoningTrace(traceId: string, conclusion: string, confidence: number): Promise<ReasoningTrace>;
-    addAlternativeReasoning(traceId: string, alternative: Omit<AlternativeReasoning, 'id'>): Promise<AlternativeReasoning>;
-    getReasoningTrace(traceId: string): Promise<ReasoningTrace | null>;
-    searchReasoningTraces(query: {
-        domain?: string;
-        complexity?: string;
-        minQuality?: number;
-        timeframe?: {
-            start: Date;
-            end: Date;
-        };
-    }, limit?: number): Promise<ReasoningTrace[]>;
-    createDecisionTree(domain: string, initialCondition: string): Promise<DecisionTree>;
-    addDecisionNode(treeId: string, parentNodeId: string, node: Omit<DecisionNode, 'id'>): Promise<DecisionNode>;
-    addEvidence(treeId: string, nodeId: string, evidence: Evidence): Promise<void>;
-    queryDecisionTree(treeId: string, context: Record<string, unknown>): Promise<DecisionNode[]>;
-    proposeEnhancement(enhancement: Omit<Enhancement, 'id' | 'status'>): Promise<Enhancement>;
-    updateEnhancementStatus(enhancementId: string, status: Enhancement['status'], feedback?: string): Promise<boolean>;
-    getEnhancementsByType(type: Enhancement['type']): Promise<Enhancement[]>;
-    addReflectionEntry(trigger: string, observation: string, analysis: string, insight: string, confidence?: number): Promise<ReflectionEntry>;
-    addActionItem(reflectionId: string, actionItem: Omit<ActionItem, 'id' | 'status'>): Promise<ActionItem>;
-    getReflectionInsights(timeframe?: {
-        start: Date;
-        end: Date;
-    }, minConfidence?: number): Promise<ReflectionEntry[]>;
-    processMemoryEvent(event: MemoryEvent): Promise<void>;
-    assessCodeQuality(code: string, _language: string, context?: Record<string, unknown>): Promise<CodeQualityMetrics>;
-    updateQualityMetrics(metrics: Partial<QualityMetrics>): Promise<void>;
-    private generateTraceId;
-    private generateStepId;
-    private generateAlternativeId;
-    private generateDecisionTreeId;
-    private generateNodeId;
-    private generateEnhancementId;
-    private generateReflectionId;
-    private generateActionItemId;
-    private assessComplexity;
-    private identifyDomain;
-    private calculateStepConfidence;
-    private identifyDependencies;
-    private updateTraceQuality;
-    private calculateReasoningQuality;
-    private calculateCoherence;
-    private calculateCompleteness;
-    private calculateAccuracy;
-    private calculateEfficiency;
-    private calculateCreativity;
-    private generateImprovementSuggestions;
-    private updateGlobalQualityMetrics;
-    private createEmptyDecisionTree;
-    private findDecisionNode;
-    private calculateTreeComplexity;
-    private calculateNodeConfidence;
-    private traverseDecisionTree;
-    private evaluateCondition;
-    private shouldAutoApprove;
-    private evaluateEnhancementImpact;
-    private generateActionItems;
-    private processCodeGenerationEvent;
-    private processBugFixEvent;
-    private processQualityImprovementEvent;
-    private processGenericEvent;
-    private manageTraceLimit;
-    private calculateMaintainability;
-    private calculateReadability;
-    private calculateTestability;
-    private calculatePerformance;
-    private calculateSecurity;
-    private calculateBugDensity;
-    private calculateCyclomaticComplexity;
-    private calculateBasicComplexity;
-    private hashCode;
-    private initializeQualityMetrics;
-}
-
 /**
  * Internal Mode System - Type Definitions
  *