Removes outdated prompt files

Removes the `Chat Prompt.txt`, `VSCode Agent/Prompt.txt`, `Warp.dev/Prompt.txt`, and `v0 Prompts and Tools/Prompt.txt` files. These files likely contain outdated prompts or configurations that are no longer needed in the current project. Removing them helps to clean up the codebase and prevent potential confusion or conflicts.
2026-02-03 21:40:53 +00:00 · 2025-07-31 01:45:01 +04:00
parent 23a65fbb9e
commit d43632a49a
91 changed files with 27187 additions and 1648 deletions
--- a/.github/Advanced_AI_Agent/prompts/memory_system.md
+++ b/.github/Advanced_AI_Agent/prompts/memory_system.md
@@ -0,0 +1,431 @@
+# 🧠 Advanced Memory System
+## Synthesized from Industry Best Practices
+
+### Overview
+
+The Advanced Memory System represents the culmination of analyzing memory patterns from leading AI assistants including Cursor, Devin AI, Manus, and others. This system enables persistent learning, context preservation, and natural memory integration across sessions.
+
+---
+
+## 🎯 Core Principles
+
+### **1. Natural Integration**
+- **Seamless Citations**: Use `[[memory:MEMORY_ID]]` format for natural memory integration
+- **Context Preservation**: Maintain important context across multiple sessions
+- **Proactive Storage**: Create memories immediately when encountering important information
+- **Selective Updates**: Update or delete memories when contradicted or augmented
+
+### **2. Multi-Level Context**
+- **User Preferences**: Communication style, expertise level, project preferences
+- **Project Patterns**: Code conventions, architecture decisions, dependencies
+- **Technical Knowledge**: Solutions, workarounds, best practices
+- **Interaction History**: Previous decisions, successful approaches, lessons learned
+
+### **3. Intelligent Management**
+- **Validation**: Verify memory accuracy before using
+- **Cleanup**: Remove outdated or incorrect memories
+- **Contradiction Handling**: Delete memories when contradicted by user
+- **Augmentation**: Update memories with new information
+
+---
+
+## 📋 Memory Types
+
+### **User Preferences Memory**
+```typescript
+interface UserPreferences {
+  communicationStyle: "detailed" | "concise" | "technical" | "conversational";
+  expertiseLevel: "beginner" | "intermediate" | "advanced" | "expert";
+  projectPreferences: {
+    preferredLanguages: string[];
+    codingStyle: "functional" | "objectOriented" | "procedural";
+    documentationLevel: "minimal" | "standard" | "comprehensive";
+  };
+  interactionPatterns: {
+    preferredResponseFormat: "summary" | "detailed" | "stepByStep";
+    learningStyle: "visual" | "handsOn" | "theoretical";
+  };
+}
+```
+
+### **Project Patterns Memory**
+```typescript
+interface ProjectPatterns {
+  codeConventions: {
+    namingConventions: Record<string, string>;
+    fileStructure: string[];
+    importPatterns: string[];
+  };
+  architectureDecisions: {
+    frameworkChoices: Record<string, string>;
+    designPatterns: string[];
+    dependencyManagement: string;
+  };
+  technicalDebt: {
+    knownIssues: string[];
+    plannedImprovements: string[];
+    workarounds: Record<string, string>;
+  };
+}
+```
+
+### **Technical Knowledge Memory**
+```typescript
+interface TechnicalKnowledge {
+  solutions: {
+    problem: string;
+    solution: string;
+    context: string;
+    effectiveness: "high" | "medium" | "low";
+  }[];
+  bestPractices: {
+    category: string;
+    practice: string;
+    rationale: string;
+    examples: string[];
+  }[];
+  workarounds: {
+    issue: string;
+    workaround: string;
+    permanentSolution?: string;
+  }[];
+}
+```
+
+### **Interaction History Memory**
+```typescript
+interface InteractionHistory {
+  decisions: {
+    context: string;
+    decision: string;
+    rationale: string;
+    outcome: "successful" | "failed" | "partial";
+  }[];
+  successfulApproaches: {
+    taskType: string;
+    approach: string;
+    keyFactors: string[];
+  }[];
+  lessonsLearned: {
+    situation: string;
+    lesson: string;
+    application: string;
+  }[];
+}
+```
+
+---
+
+## 🔧 Memory Operations
+
+### **Memory Creation**
+```typescript
+// Create a new memory
+update_memory({
+  title: "User prefers concise responses",
+  knowledge_to_store: "User prefers brief, actionable responses over detailed explanations. Focus on key points and next steps.",
+  action: "create"
+});
+```
+
+### **Memory Citation**
+```typescript
+// Use memory in response
+"Based on your preference for concise responses [[memory:user_communication_style]], I'll provide the key points directly."
+
+// Natural integration example
+"I'll implement the authentication system using JWT tokens [[memory:project_auth_pattern]], following the established patterns in your codebase."
+```
+
+### **Memory Updates**
+```typescript
+// Update existing memory
+update_memory({
+  title: "User prefers concise responses",
+  knowledge_to_store: "User prefers concise responses but appreciates detailed explanations for complex technical topics.",
+  action: "update",
+  existing_knowledge_id: "user_communication_style"
+});
+```
+
+### **Memory Deletion**
+```typescript
+// Delete contradicted memory
+update_memory({
+  action: "delete",
+  existing_knowledge_id: "outdated_technology_choice"
+});
+```
+
+---
+
+## 🎯 Memory Usage Patterns
+
+### **1. Context-Aware Responses**
+```typescript
+// Example: Adapting communication style
+if (hasMemory("user_expertise_level") === "beginner") {
+  return provideDetailedExplanation();
+} else {
+  return provideConciseSummary();
+}
+```
+
+### **2. Pattern Recognition**
+```typescript
+// Example: Recognizing recurring patterns
+if (hasMemory("similar_problem_solved")) {
+  return applyKnownSolution();
+} else {
+  return exploreNewApproach();
+}
+```
+
+### **3. Learning Integration**
+```typescript
+// Example: Learning from previous interactions
+if (hasMemory("failed_approach")) {
+  return avoidPreviousMistake();
+} else {
+  return tryProvenMethod();
+}
+```
+
+---
+
+## 📊 Memory Quality Metrics
+
+### **Accuracy Metrics**
+- **Validation Rate**: Percentage of memories verified as accurate
+- **Contradiction Rate**: Frequency of memory contradictions
+- **Update Frequency**: How often memories are updated
+- **Usage Effectiveness**: Impact of memory usage on response quality
+
+### **Performance Metrics**
+- **Retrieval Speed**: Time to access relevant memories
+- **Context Relevance**: Percentage of memories relevant to current context
+- **Memory Density**: Amount of useful information per memory
+- **Cross-Session Persistence**: Memory retention across sessions
+
+---
+
+## 🔍 Memory Search and Retrieval
+
+### **Semantic Search**
+```typescript
+// Search memories by semantic similarity
+searchMemories({
+  query: "authentication implementation",
+  context: "current_project",
+  relevanceThreshold: 0.7
+});
+```
+
+### **Context-Aware Retrieval**
+```typescript
+// Retrieve memories based on current context
+getRelevantMemories({
+  currentTask: "implement_user_auth",
+  userExpertise: "intermediate",
+  projectType: "web_application"
+});
+```
+
+### **Pattern Matching**
+```typescript
+// Find memories matching specific patterns
+findPatternMemories({
+  pattern: "error_handling",
+  technology: "python",
+  context: "api_development"
+});
+```
+
+---
+
+## 🛡️ Memory Safety and Ethics
+
+### **Privacy Protection**
+- **User Consent**: Only store memories with implicit or explicit user consent
+- **Data Minimization**: Store only necessary information
+- **Anonymization**: Remove personally identifiable information
+- **Retention Policies**: Automatically expire outdated memories
+
+### **Bias Mitigation**
+- **Diversity Awareness**: Avoid reinforcing existing biases
+- **Balanced Learning**: Learn from both successful and failed approaches
+- **Context Sensitivity**: Consider cultural and individual differences
+- **Transparent Decision Making**: Explain memory-based decisions
+
+### **Security Measures**
+- **Encryption**: Encrypt sensitive memory data
+- **Access Control**: Limit memory access to authorized operations
+- **Audit Trail**: Track memory creation, updates, and deletions
+- **Secure Storage**: Use secure storage mechanisms
+
+---
+
+## 🔮 Advanced Memory Features
+
+### **Multi-Modal Memory**
+```typescript
+interface MultiModalMemory {
+  text: string;
+  visual?: {
+    diagrams: string[];
+    screenshots: string[];
+    codeVisualizations: string[];
+  };
+  audio?: {
+    voiceNotes: string[];
+    pronunciation: Record<string, string>;
+  };
+  contextual?: {
+    environment: string;
+    timestamp: string;
+    userState: string;
+  };
+}
+```
+
+### **Predictive Memory**
+```typescript
+interface PredictiveMemory {
+  patterns: {
+    userBehavior: string[];
+    projectEvolution: string[];
+    technologyTrends: string[];
+  };
+  predictions: {
+    likelyNeeds: string[];
+    potentialIssues: string[];
+    optimizationOpportunities: string[];
+  };
+}
+```
+
+### **Collaborative Memory**
+```typescript
+interface CollaborativeMemory {
+  teamPreferences: Record<string, UserPreferences>;
+  sharedPatterns: ProjectPatterns[];
+  collectiveKnowledge: TechnicalKnowledge[];
+  teamHistory: InteractionHistory[];
+}
+```
+
+---
+
+## 📈 Memory Optimization
+
+### **Memory Compression**
+- **Semantic Compression**: Store meaning rather than exact text
+- **Pattern Extraction**: Identify and store recurring patterns
+- **Contextual Pruning**: Remove context-specific details
+- **Hierarchical Storage**: Organize memories in logical hierarchies
+
+### **Memory Retrieval Optimization**
+- **Indexing**: Create semantic indexes for fast retrieval
+- **Caching**: Cache frequently accessed memories
+- **Preloading**: Preload contextually relevant memories
+- **Parallel Processing**: Retrieve multiple memories simultaneously
+
+### **Memory Maintenance**
+- **Regular Validation**: Periodically verify memory accuracy
+- **Automatic Cleanup**: Remove outdated or low-quality memories
+- **Memory Consolidation**: Merge similar or related memories
+- **Quality Assessment**: Rate memory usefulness and accuracy
+
+---
+
+## 🎯 Best Practices
+
+### **Memory Creation**
+1. **Be Specific**: Create focused, actionable memories
+2. **Include Context**: Store relevant context with each memory
+3. **Validate Accuracy**: Verify information before storing
+4. **Use Clear Titles**: Make memories easily searchable
+
+### **Memory Usage**
+1. **Cite Naturally**: Integrate memories seamlessly into responses
+2. **Verify Relevance**: Ensure memories are applicable to current context
+3. **Update Proactively**: Keep memories current and accurate
+4. **Learn Continuously**: Improve memory quality over time
+
+### **Memory Management**
+1. **Regular Review**: Periodically review and update memories
+2. **Quality Control**: Maintain high standards for memory accuracy
+3. **Efficient Storage**: Optimize memory storage and retrieval
+4. **Privacy Protection**: Respect user privacy and data protection
+
+---
+
+## 🔧 Implementation Guidelines
+
+### **Memory Storage**
+```typescript
+// Example memory storage implementation
+class MemorySystem {
+  async createMemory(memory: Memory): Promise<string> {
+    const id = generateUniqueId();
+    await this.storage.set(id, {
+      ...memory,
+      createdAt: new Date(),
+      lastAccessed: new Date(),
+      accessCount: 0
+    });
+    return id;
+  }
+
+  async retrieveMemory(id: string): Promise<Memory | null> {
+    const memory = await this.storage.get(id);
+    if (memory) {
+      memory.lastAccessed = new Date();
+      memory.accessCount++;
+      await this.storage.set(id, memory);
+    }
+    return memory;
+  }
+
+  async searchMemories(query: string): Promise<Memory[]> {
+    // Implement semantic search
+    return this.semanticSearch.search(query);
+  }
+}
+```
+
+### **Memory Integration**
+```typescript
+// Example memory integration in responses
+class ResponseGenerator {
+  async generateResponse(userQuery: string): Promise<string> {
+    const relevantMemories = await this.memorySystem.searchMemories(userQuery);
+    
+    let response = await this.generateBaseResponse(userQuery);
+    
+    // Integrate memories naturally
+    for (const memory of relevantMemories) {
+      response = this.integrateMemory(response, memory);
+    }
+    
+    return response;
+  }
+
+  private integrateMemory(response: string, memory: Memory): string {
+    // Natural memory integration logic
+    return response.replace(
+      /(\b\w+\b)/g,
+      (match) => {
+        if (this.isRelevantToMemory(match, memory)) {
+          return `${match} [[memory:${memory.id}]]`;
+        }
+        return match;
+      }
+    );
+  }
+}
+```
+
+---
+
+*This memory system synthesizes the best patterns from Cursor's natural citation format, Devin AI's context preservation, Manus's comprehensive tool integration, and other leading AI assistants to create the most advanced memory system possible.*