elsabro 2.3.0 → 3.7.0

package/references/multi-project-memory.md

@@ -0,0 +1,1182 @@
+# ELSABRO Multi-Project Memory System
+
+> Sistema de memoria compartida entre proyectos para reutilizar conocimiento y aprendizajes.
+
+## Arquitectura General
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                     Multi-Project Memory System                          │
+├─────────────────────────────────────────────────────────────────────────┤
+│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐         │
+│  │ SharedMemoryHub │  │  ProjectLinker  │  │ KnowledgeSync   │         │
+│  │  ─────────────  │  │  ─────────────  │  │  ─────────────  │         │
+│  │ • Global store  │  │ • Link projects │  │ • Sync changes  │         │
+│  │ • Namespaces    │  │ • Permissions   │  │ • Conflicts     │         │
+│  │ • Versioning    │  │ • Inheritance   │  │ • Webhooks      │         │
+│  └─────────────────┘  └─────────────────┘  └─────────────────┘         │
+│                              │                                          │
+│  ┌───────────────────────────┴───────────────────────────────┐         │
+│  │                  CrossProjectSearch                        │         │
+│  │  • Semantic search • Pattern matching • Relevance ranking │         │
+│  └────────────────────────────────────────────────────────────┘         │
+│                              │                                          │
+│  ┌───────────────────────────┴───────────────────────────────┐         │
+│  │                  KnowledgeExtractor                        │         │
+│  │  • Auto-extract patterns • Mistakes • Best practices      │         │
+│  └────────────────────────────────────────────────────────────┘         │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 1. SharedMemoryHub
+
+### Propósito
+Almacén central de conocimiento compartido entre proyectos con namespacing y versionado.
+
+### Interfaz
+
+```typescript
+interface MemoryNamespace {
+  id: string;
+  name: string;
+  description?: string;
+  visibility: 'private' | 'team' | 'public';
+  owner: string;
+  projects: string[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface SharedMemoryEntry {
+  id: string;
+  namespace: string;
+  type: 'pattern' | 'mistake' | 'preference' | 'snippet' | 'architecture' | 'dependency';
+  title: string;
+  content: string;
+  metadata: Record<string, unknown>;
+  tags: string[];
+  sourceProject?: string;
+  version: number;
+  embedding?: number[];  // For semantic search
+  usageCount: number;
+  lastUsed?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface SharedMemoryHub {
+  // Namespaces
+  createNamespace(config: Omit<MemoryNamespace, 'id' | 'createdAt' | 'updatedAt'>): Promise<MemoryNamespace>;
+  getNamespace(id: string): Promise<MemoryNamespace | null>;
+  listNamespaces(filter?: { visibility?: string; owner?: string }): Promise<MemoryNamespace[]>;
+  updateNamespace(id: string, updates: Partial<MemoryNamespace>): Promise<MemoryNamespace>;
+  deleteNamespace(id: string): Promise<void>;
+
+  // Entries
+  store(entry: Omit<SharedMemoryEntry, 'id' | 'version' | 'createdAt' | 'updatedAt'>): Promise<SharedMemoryEntry>;
+  get(id: string): Promise<SharedMemoryEntry | null>;
+  update(id: string, updates: Partial<SharedMemoryEntry>): Promise<SharedMemoryEntry>;
+  delete(id: string): Promise<void>;
+
+  // Query
+  query(options: MemoryQueryOptions): Promise<SharedMemoryEntry[]>;
+  search(text: string, options?: SearchOptions): Promise<SearchResult[]>;
+  findSimilar(entryId: string, limit?: number): Promise<SharedMemoryEntry[]>;
+
+  // Sync
+  exportNamespace(namespaceId: string): Promise<ExportedMemory>;
+  importNamespace(data: ExportedMemory, options?: ImportOptions): Promise<MemoryNamespace>;
+
+  // Stats
+  getStats(namespaceId?: string): Promise<MemoryStats>;
+}
+
+interface MemoryQueryOptions {
+  namespace?: string;
+  type?: SharedMemoryEntry['type'];
+  tags?: string[];
+  sourceProject?: string;
+  minUsageCount?: number;
+  limit?: number;
+  offset?: number;
+  orderBy?: 'createdAt' | 'updatedAt' | 'usageCount' | 'relevance';
+}
+
+interface SearchResult {
+  entry: SharedMemoryEntry;
+  score: number;
+  highlights: string[];
+}
+```
+
+### Implementación
+
+```typescript
+class SharedMemoryHubImpl implements SharedMemoryHub {
+  private namespaces: Map<string, MemoryNamespace> = new Map();
+  private entries: Map<string, SharedMemoryEntry> = new Map();
+  private embeddings: Map<string, number[]> = new Map();
+  private storagePath: string;
+
+  constructor(private config: SharedMemoryConfig) {
+    this.storagePath = config.storagePath || '~/.elsabro/shared-memory';
+    this.loadFromDisk();
+  }
+
+  private async loadFromDisk(): Promise<void> {
+    try {
+      const namespacesPath = path.join(this.storagePath, 'namespaces.json');
+      const entriesPath = path.join(this.storagePath, 'entries.json');
+
+      if (await this.fileExists(namespacesPath)) {
+        const data = JSON.parse(await fs.readFile(namespacesPath, 'utf-8'));
+        for (const ns of data) {
+          this.namespaces.set(ns.id, ns);
+        }
+      }
+
+      if (await this.fileExists(entriesPath)) {
+        const data = JSON.parse(await fs.readFile(entriesPath, 'utf-8'));
+        for (const entry of data) {
+          this.entries.set(entry.id, entry);
+          if (entry.embedding) {
+            this.embeddings.set(entry.id, entry.embedding);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn('Failed to load shared memory from disk:', error);
+    }
+  }
+
+  private async saveToDisk(): Promise<void> {
+    await fs.mkdir(this.storagePath, { recursive: true });
+
+    const namespacesPath = path.join(this.storagePath, 'namespaces.json');
+    const entriesPath = path.join(this.storagePath, 'entries.json');
+
+    await fs.writeFile(
+      namespacesPath,
+      JSON.stringify(Array.from(this.namespaces.values()), null, 2)
+    );
+
+    await fs.writeFile(
+      entriesPath,
+      JSON.stringify(Array.from(this.entries.values()), null, 2)
+    );
+  }
+
+  async createNamespace(
+    config: Omit<MemoryNamespace, 'id' | 'createdAt' | 'updatedAt'>
+  ): Promise<MemoryNamespace> {
+    const namespace: MemoryNamespace = {
+      ...config,
+      id: `ns_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+
+    this.namespaces.set(namespace.id, namespace);
+    await this.saveToDisk();
+    return namespace;
+  }
+
+  async store(
+    entry: Omit<SharedMemoryEntry, 'id' | 'version' | 'createdAt' | 'updatedAt'>
+  ): Promise<SharedMemoryEntry> {
+    const fullEntry: SharedMemoryEntry = {
+      ...entry,
+      id: `mem_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      version: 1,
+      usageCount: 0,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+
+    // Generate embedding for semantic search
+    if (this.config.enableSemanticSearch) {
+      fullEntry.embedding = await this.generateEmbedding(
+        `${entry.title} ${entry.content} ${entry.tags.join(' ')}`
+      );
+      this.embeddings.set(fullEntry.id, fullEntry.embedding);
+    }
+
+    this.entries.set(fullEntry.id, fullEntry);
+    await this.saveToDisk();
+    return fullEntry;
+  }
+
+  async get(id: string): Promise<SharedMemoryEntry | null> {
+    const entry = this.entries.get(id);
+    if (entry) {
+      // Update usage stats
+      entry.usageCount++;
+      entry.lastUsed = new Date().toISOString();
+      await this.saveToDisk();
+    }
+    return entry || null;
+  }
+
+  async update(id: string, updates: Partial<SharedMemoryEntry>): Promise<SharedMemoryEntry> {
+    const existing = this.entries.get(id);
+    if (!existing) {
+      throw new Error(`Entry not found: ${id}`);
+    }
+
+    const updated: SharedMemoryEntry = {
+      ...existing,
+      ...updates,
+      id: existing.id, // Prevent ID change
+      version: existing.version + 1,
+      updatedAt: new Date().toISOString()
+    };
+
+    // Regenerate embedding if content changed
+    if (updates.title || updates.content || updates.tags) {
+      if (this.config.enableSemanticSearch) {
+        updated.embedding = await this.generateEmbedding(
+          `${updated.title} ${updated.content} ${updated.tags.join(' ')}`
+        );
+        this.embeddings.set(updated.id, updated.embedding);
+      }
+    }
+
+    this.entries.set(id, updated);
+    await this.saveToDisk();
+    return updated;
+  }
+
+  async query(options: MemoryQueryOptions): Promise<SharedMemoryEntry[]> {
+    let results = Array.from(this.entries.values());
+
+    // Apply filters
+    if (options.namespace) {
+      results = results.filter(e => e.namespace === options.namespace);
+    }
+    if (options.type) {
+      results = results.filter(e => e.type === options.type);
+    }
+    if (options.tags && options.tags.length > 0) {
+      results = results.filter(e =>
+        options.tags!.some(tag => e.tags.includes(tag))
+      );
+    }
+    if (options.sourceProject) {
+      results = results.filter(e => e.sourceProject === options.sourceProject);
+    }
+    if (options.minUsageCount !== undefined) {
+      results = results.filter(e => e.usageCount >= options.minUsageCount!);
+    }
+
+    // Sort
+    switch (options.orderBy) {
+      case 'createdAt':
+        results.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        break;
+      case 'updatedAt':
+        results.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        break;
+      case 'usageCount':
+        results.sort((a, b) => b.usageCount - a.usageCount);
+        break;
+      default:
+        results.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+
+    // Pagination
+    const offset = options.offset || 0;
+    const limit = options.limit || 50;
+    return results.slice(offset, offset + limit);
+  }
+
+  async search(text: string, options?: SearchOptions): Promise<SearchResult[]> {
+    const results: SearchResult[] = [];
+    const searchTerms = text.toLowerCase().split(/\s+/);
+
+    for (const entry of this.entries.values()) {
+      // Apply namespace filter
+      if (options?.namespace && entry.namespace !== options.namespace) {
+        continue;
+      }
+
+      // Text search
+      const searchableText = `${entry.title} ${entry.content} ${entry.tags.join(' ')}`.toLowerCase();
+      const matchedTerms = searchTerms.filter(term => searchableText.includes(term));
+
+      if (matchedTerms.length === 0) continue;
+
+      // Calculate score
+      let score = matchedTerms.length / searchTerms.length;
+
+      // Boost exact title match
+      if (entry.title.toLowerCase().includes(text.toLowerCase())) {
+        score += 0.5;
+      }
+
+      // Boost by usage
+      score += Math.min(entry.usageCount / 100, 0.2);
+
+      // Generate highlights
+      const highlights = this.generateHighlights(entry.content, searchTerms);
+
+      results.push({ entry, score, highlights });
+    }
+
+    // Semantic search if enabled
+    if (this.config.enableSemanticSearch && options?.useSemanticSearch !== false) {
+      const semanticResults = await this.semanticSearch(text, options?.limit || 10);
+
+      // Merge results
+      for (const sr of semanticResults) {
+        const existing = results.find(r => r.entry.id === sr.entry.id);
+        if (existing) {
+          existing.score = Math.max(existing.score, sr.score);
+        } else {
+          results.push(sr);
+        }
+      }
+    }
+
+    // Sort by score
+    results.sort((a, b) => b.score - a.score);
+
+    return results.slice(0, options?.limit || 20);
+  }
+
+  private async semanticSearch(text: string, limit: number): Promise<SearchResult[]> {
+    const queryEmbedding = await this.generateEmbedding(text);
+    const results: SearchResult[] = [];
+
+    for (const [id, embedding] of this.embeddings) {
+      const similarity = this.cosineSimilarity(queryEmbedding, embedding);
+      if (similarity > 0.5) { // Threshold
+        const entry = this.entries.get(id)!;
+        results.push({
+          entry,
+          score: similarity,
+          highlights: []
+        });
+      }
+    }
+
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+
+  async findSimilar(entryId: string, limit: number = 5): Promise<SharedMemoryEntry[]> {
+    const sourceEntry = this.entries.get(entryId);
+    if (!sourceEntry) return [];
+
+    const sourceEmbedding = this.embeddings.get(entryId);
+    if (!sourceEmbedding) {
+      // Fallback to tag-based similarity
+      return this.findSimilarByTags(sourceEntry, limit);
+    }
+
+    const similarities: Array<{ entry: SharedMemoryEntry; score: number }> = [];
+
+    for (const [id, embedding] of this.embeddings) {
+      if (id === entryId) continue;
+
+      const similarity = this.cosineSimilarity(sourceEmbedding, embedding);
+      const entry = this.entries.get(id)!;
+
+      // Boost same type
+      const typeBoost = entry.type === sourceEntry.type ? 0.1 : 0;
+
+      similarities.push({
+        entry,
+        score: similarity + typeBoost
+      });
+    }
+
+    similarities.sort((a, b) => b.score - a.score);
+    return similarities.slice(0, limit).map(s => s.entry);
+  }
+
+  private findSimilarByTags(entry: SharedMemoryEntry, limit: number): SharedMemoryEntry[] {
+    const results: Array<{ entry: SharedMemoryEntry; score: number }> = [];
+
+    for (const [id, other] of this.entries) {
+      if (id === entry.id) continue;
+
+      const commonTags = entry.tags.filter(t => other.tags.includes(t));
+      if (commonTags.length === 0) continue;
+
+      const score = commonTags.length / Math.max(entry.tags.length, other.tags.length);
+      results.push({ entry: other, score });
+    }
+
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit).map(r => r.entry);
+  }
+
+  async exportNamespace(namespaceId: string): Promise<ExportedMemory> {
+    const namespace = this.namespaces.get(namespaceId);
+    if (!namespace) {
+      throw new Error(`Namespace not found: ${namespaceId}`);
+    }
+
+    const entries = Array.from(this.entries.values())
+      .filter(e => e.namespace === namespaceId);
+
+    return {
+      version: '1.0.0',
+      exportedAt: new Date().toISOString(),
+      namespace,
+      entries
+    };
+  }
+
+  async importNamespace(
+    data: ExportedMemory,
+    options?: ImportOptions
+  ): Promise<MemoryNamespace> {
+    // Create or update namespace
+    let namespace: MemoryNamespace;
+
+    if (options?.mergeInto) {
+      namespace = this.namespaces.get(options.mergeInto)!;
+      if (!namespace) {
+        throw new Error(`Target namespace not found: ${options.mergeInto}`);
+      }
+    } else {
+      namespace = await this.createNamespace({
+        ...data.namespace,
+        name: options?.rename || data.namespace.name
+      });
+    }
+
+    // Import entries
+    for (const entry of data.entries) {
+      // Check for duplicates
+      if (options?.skipDuplicates) {
+        const exists = Array.from(this.entries.values()).some(
+          e => e.namespace === namespace.id &&
+               e.title === entry.title &&
+               e.type === entry.type
+        );
+        if (exists) continue;
+      }
+
+      await this.store({
+        ...entry,
+        namespace: namespace.id,
+        sourceProject: entry.sourceProject || data.namespace.name
+      });
+    }
+
+    return namespace;
+  }
+
+  async getStats(namespaceId?: string): Promise<MemoryStats> {
+    let entries = Array.from(this.entries.values());
+
+    if (namespaceId) {
+      entries = entries.filter(e => e.namespace === namespaceId);
+    }
+
+    const byType = new Map<string, number>();
+    let totalUsage = 0;
+
+    for (const entry of entries) {
+      byType.set(entry.type, (byType.get(entry.type) || 0) + 1);
+      totalUsage += entry.usageCount;
+    }
+
+    return {
+      totalEntries: entries.length,
+      byType: Object.fromEntries(byType),
+      totalUsage,
+      averageUsage: entries.length > 0 ? totalUsage / entries.length : 0,
+      namespaceCount: namespaceId ? 1 : this.namespaces.size
+    };
+  }
+
+  private async generateEmbedding(text: string): Promise<number[]> {
+    // Simple hash-based embedding for demo
+    // In production, use a proper embedding model
+    const hash = this.simpleHash(text);
+    const embedding: number[] = [];
+
+    for (let i = 0; i < 128; i++) {
+      embedding.push(Math.sin(hash * (i + 1)) * 0.5 + 0.5);
+    }
+
+    return embedding;
+  }
+
+  private simpleHash(str: string): number {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash;
+    }
+    return hash;
+  }
+
+  private cosineSimilarity(a: number[], b: number[]): number {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+
+  private generateHighlights(content: string, terms: string[]): string[] {
+    const highlights: string[] = [];
+    const sentences = content.split(/[.!?]+/);
+
+    for (const sentence of sentences) {
+      const lower = sentence.toLowerCase();
+      if (terms.some(term => lower.includes(term))) {
+        highlights.push(sentence.trim());
+        if (highlights.length >= 3) break;
+      }
+    }
+
+    return highlights;
+  }
+
+  private async fileExists(path: string): Promise<boolean> {
+    try {
+      await fs.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+```
+
+---
+
+## 2. ProjectLinker
+
+### Propósito
+Gestiona las relaciones entre proyectos para compartir conocimiento.
+
+### Interfaz
+
+```typescript
+interface ProjectLink {
+  id: string;
+  sourceProject: string;
+  targetProject: string;
+  direction: 'unidirectional' | 'bidirectional';
+  shareTypes: SharedMemoryEntry['type'][];
+  autoSync: boolean;
+  syncInterval?: number;
+  permissions: LinkPermissions;
+  createdAt: string;
+}
+
+interface LinkPermissions {
+  canRead: boolean;
+  canWrite: boolean;
+  canDelete: boolean;
+  canShare: boolean;
+}
+
+interface ProjectLinker {
+  // Link management
+  createLink(config: Omit<ProjectLink, 'id' | 'createdAt'>): Promise<ProjectLink>;
+  getLink(id: string): Promise<ProjectLink | null>;
+  listLinks(projectId: string): Promise<ProjectLink[]>;
+  updateLink(id: string, updates: Partial<ProjectLink>): Promise<ProjectLink>;
+  removeLink(id: string): Promise<void>;
+
+  // Project operations
+  registerProject(project: ProjectInfo): Promise<void>;
+  unregisterProject(projectId: string): Promise<void>;
+  getProjectInfo(projectId: string): Promise<ProjectInfo | null>;
+  listProjects(): Promise<ProjectInfo[]>;
+
+  // Sharing
+  shareEntry(entryId: string, targetProjectId: string): Promise<void>;
+  unshareEntry(entryId: string, targetProjectId: string): Promise<void>;
+  getSharedWith(entryId: string): Promise<string[]>;
+
+  // Discovery
+  discoverRelatedProjects(projectId: string): Promise<ProjectSuggestion[]>;
+}
+
+interface ProjectInfo {
+  id: string;
+  name: string;
+  path: string;
+  techStack: string[];
+  description?: string;
+  lastActive: string;
+}
+
+interface ProjectSuggestion {
+  project: ProjectInfo;
+  relevanceScore: number;
+  reason: string;
+  sharedTags: string[];
+}
+```
+
+### Implementación
+
+```typescript
+class ProjectLinkerImpl implements ProjectLinker {
+  private links: Map<string, ProjectLink> = new Map();
+  private projects: Map<string, ProjectInfo> = new Map();
+  private entryShares: Map<string, Set<string>> = new Map(); // entryId -> projectIds
+
+  constructor(
+    private hub: SharedMemoryHub,
+    private config: ProjectLinkerConfig
+  ) {
+    this.loadState();
+  }
+
+  async createLink(
+    config: Omit<ProjectLink, 'id' | 'createdAt'>
+  ): Promise<ProjectLink> {
+    // Validate projects exist
+    if (!this.projects.has(config.sourceProject)) {
+      throw new Error(`Source project not found: ${config.sourceProject}`);
+    }
+    if (!this.projects.has(config.targetProject)) {
+      throw new Error(`Target project not found: ${config.targetProject}`);
+    }
+
+    const link: ProjectLink = {
+      ...config,
+      id: `link_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      createdAt: new Date().toISOString()
+    };
+
+    this.links.set(link.id, link);
+    await this.saveState();
+
+    // Setup auto-sync if enabled
+    if (config.autoSync && config.syncInterval) {
+      this.setupAutoSync(link);
+    }
+
+    return link;
+  }
+
+  async listLinks(projectId: string): Promise<ProjectLink[]> {
+    return Array.from(this.links.values()).filter(
+      link => link.sourceProject === projectId || link.targetProject === projectId
+    );
+  }
+
+  async registerProject(project: ProjectInfo): Promise<void> {
+    this.projects.set(project.id, {
+      ...project,
+      lastActive: new Date().toISOString()
+    });
+    await this.saveState();
+  }
+
+  async shareEntry(entryId: string, targetProjectId: string): Promise<void> {
+    if (!this.entryShares.has(entryId)) {
+      this.entryShares.set(entryId, new Set());
+    }
+    this.entryShares.get(entryId)!.add(targetProjectId);
+    await this.saveState();
+  }
+
+  async discoverRelatedProjects(projectId: string): Promise<ProjectSuggestion[]> {
+    const currentProject = this.projects.get(projectId);
+    if (!currentProject) return [];
+
+    const suggestions: ProjectSuggestion[] = [];
+
+    for (const [id, project] of this.projects) {
+      if (id === projectId) continue;
+
+      // Calculate relevance
+      const sharedTags = currentProject.techStack.filter(
+        tech => project.techStack.includes(tech)
+      );
+
+      if (sharedTags.length === 0) continue;
+
+      const relevanceScore = sharedTags.length /
+        Math.max(currentProject.techStack.length, project.techStack.length);
+
+      suggestions.push({
+        project,
+        relevanceScore,
+        reason: this.generateReason(sharedTags),
+        sharedTags
+      });
+    }
+
+    // Sort by relevance
+    suggestions.sort((a, b) => b.relevanceScore - a.relevanceScore);
+    return suggestions.slice(0, 5);
+  }
+
+  private generateReason(sharedTags: string[]): string {
+    if (sharedTags.length >= 3) {
+      return `Shares ${sharedTags.length} technologies: ${sharedTags.slice(0, 3).join(', ')}`;
+    } else if (sharedTags.length > 0) {
+      return `Both use ${sharedTags.join(' and ')}`;
+    }
+    return 'Potentially related project';
+  }
+
+  private setupAutoSync(link: ProjectLink): void {
+    setInterval(async () => {
+      await this.syncLink(link);
+    }, link.syncInterval);
+  }
+
+  private async syncLink(link: ProjectLink): Promise<void> {
+    // Get entries from source that match share types
+    const entries = await this.hub.query({
+      sourceProject: link.sourceProject,
+      type: link.shareTypes[0] // Simplified - would iterate all types
+    });
+
+    // Share each to target
+    for (const entry of entries) {
+      await this.shareEntry(entry.id, link.targetProject);
+    }
+  }
+
+  private async loadState(): Promise<void> {
+    // Load from disk
+  }
+
+  private async saveState(): Promise<void> {
+    // Save to disk
+  }
+}
+```
+
+---
+
+## 3. KnowledgeSync
+
+### Propósito
+Sincroniza conocimiento entre proyectos con manejo de conflictos.
+
+### Interfaz
+
+```typescript
+interface SyncOperation {
+  id: string;
+  type: 'push' | 'pull' | 'merge';
+  sourceProject: string;
+  targetProject: string;
+  entries: string[];
+  status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'conflict';
+  conflicts?: SyncConflict[];
+  startedAt: string;
+  completedAt?: string;
+}
+
+interface SyncConflict {
+  entryId: string;
+  localVersion: SharedMemoryEntry;
+  remoteVersion: SharedMemoryEntry;
+  resolution?: 'local' | 'remote' | 'merge' | 'skip';
+}
+
+interface KnowledgeSync {
+  // Sync operations
+  push(sourceProject: string, targetProject: string, entryIds?: string[]): Promise<SyncOperation>;
+  pull(sourceProject: string, targetProject: string, entryIds?: string[]): Promise<SyncOperation>;
+  sync(projectA: string, projectB: string): Promise<SyncOperation>;
+
+  // Conflict resolution
+  getConflicts(operationId: string): Promise<SyncConflict[]>;
+  resolveConflict(operationId: string, entryId: string, resolution: SyncConflict['resolution']): Promise<void>;
+  resolveAllConflicts(operationId: string, resolution: SyncConflict['resolution']): Promise<void>;
+
+  // Status
+  getOperation(id: string): Promise<SyncOperation | null>;
+  listOperations(projectId: string): Promise<SyncOperation[]>;
+  cancelOperation(id: string): Promise<void>;
+
+  // Webhooks
+  registerWebhook(projectId: string, url: string, events: string[]): Promise<string>;
+  removeWebhook(webhookId: string): Promise<void>;
+}
+```
+
+### Implementación
+
+```typescript
+class KnowledgeSyncImpl implements KnowledgeSync {
+  private operations: Map<string, SyncOperation> = new Map();
+  private webhooks: Map<string, WebhookConfig[]> = new Map();
+
+  constructor(
+    private hub: SharedMemoryHub,
+    private linker: ProjectLinker
+  ) {}
+
+  async push(
+    sourceProject: string,
+    targetProject: string,
+    entryIds?: string[]
+  ): Promise<SyncOperation> {
+    const operation: SyncOperation = {
+      id: `sync_${Date.now()}`,
+      type: 'push',
+      sourceProject,
+      targetProject,
+      entries: entryIds || [],
+      status: 'pending',
+      startedAt: new Date().toISOString()
+    };
+
+    this.operations.set(operation.id, operation);
+
+    try {
+      operation.status = 'in_progress';
+
+      // Get entries to sync
+      let entries: SharedMemoryEntry[];
+      if (entryIds && entryIds.length > 0) {
+        entries = await Promise.all(
+          entryIds.map(id => this.hub.get(id))
+        ).then(results => results.filter((e): e is SharedMemoryEntry => e !== null));
+      } else {
+        entries = await this.hub.query({ sourceProject });
+      }
+
+      operation.entries = entries.map(e => e.id);
+
+      // Check for conflicts
+      const conflicts: SyncConflict[] = [];
+      for (const entry of entries) {
+        const existingEntries = await this.hub.query({
+          sourceProject: targetProject,
+          type: entry.type
+        });
+
+        const duplicate = existingEntries.find(
+          e => e.title === entry.title
+        );
+
+        if (duplicate && duplicate.version !== entry.version) {
+          conflicts.push({
+            entryId: entry.id,
+            localVersion: duplicate,
+            remoteVersion: entry
+          });
+        }
+      }
+
+      if (conflicts.length > 0) {
+        operation.status = 'conflict';
+        operation.conflicts = conflicts;
+      } else {
+        // No conflicts, proceed with sync
+        for (const entry of entries) {
+          await this.hub.store({
+            ...entry,
+            id: undefined as any, // Generate new ID
+            sourceProject: targetProject,
+            metadata: {
+              ...entry.metadata,
+              syncedFrom: sourceProject,
+              syncedAt: new Date().toISOString()
+            }
+          });
+        }
+
+        operation.status = 'completed';
+        operation.completedAt = new Date().toISOString();
+
+        // Trigger webhooks
+        await this.triggerWebhooks(targetProject, 'sync:completed', operation);
+      }
+    } catch (error) {
+      operation.status = 'failed';
+      operation.completedAt = new Date().toISOString();
+    }
+
+    return operation;
+  }
+
+  async resolveConflict(
+    operationId: string,
+    entryId: string,
+    resolution: SyncConflict['resolution']
+  ): Promise<void> {
+    const operation = this.operations.get(operationId);
+    if (!operation || !operation.conflicts) {
+      throw new Error('Operation not found or has no conflicts');
+    }
+
+    const conflict = operation.conflicts.find(c => c.entryId === entryId);
+    if (!conflict) {
+      throw new Error('Conflict not found');
+    }
+
+    conflict.resolution = resolution;
+
+    // Apply resolution
+    switch (resolution) {
+      case 'local':
+        // Keep local, do nothing
+        break;
+      case 'remote':
+        // Overwrite with remote
+        await this.hub.update(conflict.localVersion.id, conflict.remoteVersion);
+        break;
+      case 'merge':
+        // Merge content
+        const merged = this.mergeEntries(conflict.localVersion, conflict.remoteVersion);
+        await this.hub.update(conflict.localVersion.id, merged);
+        break;
+      case 'skip':
+        // Do nothing
+        break;
+    }
+
+    // Check if all conflicts are resolved
+    const unresolvedConflicts = operation.conflicts.filter(c => !c.resolution);
+    if (unresolvedConflicts.length === 0) {
+      operation.status = 'completed';
+      operation.completedAt = new Date().toISOString();
+    }
+  }
+
+  private mergeEntries(
+    local: SharedMemoryEntry,
+    remote: SharedMemoryEntry
+  ): Partial<SharedMemoryEntry> {
+    return {
+      content: `${local.content}\n\n---\n\n${remote.content}`,
+      tags: [...new Set([...local.tags, ...remote.tags])],
+      metadata: {
+        ...local.metadata,
+        ...remote.metadata,
+        merged: true,
+        mergedAt: new Date().toISOString()
+      }
+    };
+  }
+
+  private async triggerWebhooks(
+    projectId: string,
+    event: string,
+    data: unknown
+  ): Promise<void> {
+    const projectWebhooks = this.webhooks.get(projectId) || [];
+
+    for (const webhook of projectWebhooks) {
+      if (!webhook.events.includes(event)) continue;
+
+      try {
+        await fetch(webhook.url, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ event, data, timestamp: new Date().toISOString() })
+        });
+      } catch (error) {
+        console.warn(`Webhook failed: ${webhook.url}`, error);
+      }
+    }
+  }
+}
+```
+
+---
+
+## 4. CrossProjectSearch
+
+### Propósito
+Búsqueda semántica y por patrones a través de múltiples proyectos.
+
+### Interfaz
+
+```typescript
+interface CrossProjectSearchOptions {
+  query: string;
+  projects?: string[];  // Search specific projects, or all if not specified
+  types?: SharedMemoryEntry['type'][];
+  minRelevance?: number;
+  limit?: number;
+  includePrivate?: boolean;
+  useSemanticSearch?: boolean;
+}
+
+interface CrossProjectSearchResult {
+  entry: SharedMemoryEntry;
+  project: ProjectInfo;
+  relevanceScore: number;
+  highlights: string[];
+  matchType: 'exact' | 'partial' | 'semantic';
+}
+
+interface CrossProjectSearch {
+  search(options: CrossProjectSearchOptions): Promise<CrossProjectSearchResult[]>;
+  searchPatterns(pattern: string, projects?: string[]): Promise<CrossProjectSearchResult[]>;
+  searchByTags(tags: string[], projects?: string[]): Promise<CrossProjectSearchResult[]>;
+  getSuggestions(partialQuery: string): Promise<string[]>;
+}
+```
+
+### Uso
+
+```typescript
+const search = new CrossProjectSearch(hub, linker);
+
+// Search across all projects
+const results = await search.search({
+  query: 'authentication JWT refresh token',
+  types: ['pattern', 'snippet'],
+  minRelevance: 0.5,
+  limit: 20
+});
+
+// Display results
+for (const result of results) {
+  console.log(`[${result.project.name}] ${result.entry.title}`);
+  console.log(`  Type: ${result.entry.type} | Score: ${result.relevanceScore.toFixed(2)}`);
+  console.log(`  ${result.highlights[0]}`);
+}
+```
+
+---
+
+## 5. KnowledgeExtractor
+
+### Propósito
+Extrae automáticamente patrones, errores y mejores prácticas del código y conversaciones.
+
+### Interfaz
+
+```typescript
+interface ExtractionSource {
+  type: 'code' | 'conversation' | 'commit' | 'review';
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+
+interface ExtractedKnowledge {
+  type: SharedMemoryEntry['type'];
+  title: string;
+  content: string;
+  confidence: number;
+  tags: string[];
+  source: string;
+}
+
+interface KnowledgeExtractor {
+  extract(source: ExtractionSource): Promise<ExtractedKnowledge[]>;
+  extractPatterns(code: string): Promise<ExtractedKnowledge[]>;
+  extractMistakes(conversation: string): Promise<ExtractedKnowledge[]>;
+  extractPreferences(history: string[]): Promise<ExtractedKnowledge[]>;
+  autoStore(knowledge: ExtractedKnowledge, namespace: string): Promise<SharedMemoryEntry>;
+}
+```
+
+### Triggers de Extracción
+
+```typescript
+// Auto-extract on user correction
+const correctionPattern = /no,?\s+(use|do|prefer|always|never)/i;
+
+// Auto-extract on explicit teaching
+const teachingPatterns = [
+  /in this project,?\s+we\s+(always|never|prefer)/i,
+  /remember to\s+/i,
+  /don't forget\s+/i,
+  /the pattern here is\s+/i
+];
+
+// Auto-extract from code review
+const reviewPatterns = [
+  /this could be improved by/i,
+  /better approach would be/i,
+  /avoid doing/i
+];
+```
+
+---
+
+## 6. Comandos CLI
+
+```bash
+# Listar proyectos registrados
+/elsabro:memory projects
+
+# Registrar proyecto actual
+/elsabro:memory register
+
+# Buscar en todos los proyectos
+/elsabro:memory search "authentication pattern"
+
+# Compartir conocimiento
+/elsabro:memory share <entry-id> --to <project>
+
+# Ver sugerencias de proyectos relacionados
+/elsabro:memory discover
+
+# Sincronizar con otro proyecto
+/elsabro:memory sync <project> --direction bidirectional
+
+# Exportar namespace
+/elsabro:memory export <namespace> --output memory-export.json
+
+# Importar namespace
+/elsabro:memory import memory-export.json --merge-into default
+```
+
+---
+
+## 7. Dashboard
+
+```
+╔══════════════════════════════════════════════════════════════════════════════╗
+║                         Multi-Project Memory Hub                              ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║  Namespaces: 3  │  Entries: 247  │  Projects: 8  │  Links: 12                ║
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                              Recent Activity                                  ║
+├──────────────────────────────────────────────────────────────────────────────┤
+│  [2h ago]  Pattern synced: "React Query cache pattern" → webapp-2            │
+│  [3h ago]  Mistake learned: "Don't use any in TypeScript interfaces"         │
+│  [5h ago]  Link created: mobile-app ↔ webapp-1 (bidirectional)               │
+│  [1d ago]  Preference stored: "Prefer Zod over Yup for validation"           │
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                            Top Shared Knowledge                               │
+├──────────────────────────────────────────────────────────────────────────────┤
+│  1. [pattern] JWT Authentication Flow          Used: 47x  Projects: 5        │
+│  2. [pattern] Error Boundary Component         Used: 38x  Projects: 4        │
+│  3. [mistake] Forgot to handle loading state   Used: 29x  Projects: 6        │
+│  4. [snippet] API Client with Retry            Used: 24x  Projects: 3        │
+│  5. [preference] Use pnpm over npm             Used: 19x  Projects: 7        │
+╠══════════════════════════════════════════════════════════════════════════════╣
+║                           Related Projects                                    │
+├──────────────────────────────────────────────────────────────────────────────┤
+│  Current: webapp-1 (Next.js, TypeScript, Prisma)                             │
+│                                                                               │
+│  Suggested links:                                                             │
+│  • webapp-2 (95% match) - Shares: Next.js, TypeScript, TailwindCSS           │
+│  • api-service (78% match) - Shares: TypeScript, Prisma                      │
+│  • mobile-app (62% match) - Shares: TypeScript, React                        │
+╚══════════════════════════════════════════════════════════════════════════════╝
+```
+
+---
+
+## Referencias
+
+- **REF-009**: Memory System
+- **REF-019**: Event-Driven Architecture
+- **REF-029**: Esta referencia (Multi-Project Memory)