sigma-memory 0.1.0

package/src/index.ts

@@ -0,0 +1,178 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync, mkdirSync } from 'fs';
+import { NotesManager } from './notes.js';
+import { OntologyManager } from './ontology.js';
+import { QMDManager } from './qmd.js';
+import type { MemoryConfig, UnifiedSearchResult, MemoryStatus } from './types.js';
+
+export class SigmaMemory {
+  public readonly notes: NotesManager;
+  public readonly ontology: OntologyManager;
+  public readonly qmd: QMDManager;
+  private readonly config: MemoryConfig;
+
+  constructor(config?: Partial<MemoryConfig>) {
+    // Configuration par défaut
+    const defaultConfig: MemoryConfig = {
+      memoryDir: join(homedir(), '.phi', 'memory'),
+      projectMemoryDir: join(process.cwd(), '.phi', 'memory'),
+      ontologyPath: join(homedir(), '.phi', 'memory', 'ontology', 'graph.jsonl'),
+      qmdEnabled: true,
+      qmdCommand: 'qmd'
+    };
+
+    this.config = { ...defaultConfig, ...config };
+
+    // Initialise les managers
+    this.notes = new NotesManager(this.config);
+    this.ontology = new OntologyManager(this.config);
+    this.qmd = new QMDManager(this.config);
+  }
+
+  /**
+   * Recherche unifiée : cherche dans notes + ontology + QMD, combine les résultats
+   */
+  async search(query: string): Promise<UnifiedSearchResult[]> {
+    const results: UnifiedSearchResult[] = [];
+
+    // Recherche dans les notes
+    try {
+      const notesResults = this.notes.search(query);
+      for (const result of notesResults) {
+        results.push({
+          source: 'notes',
+          type: 'note',
+          score: 0.8, // Score par défaut pour les notes
+          data: result
+        });
+      }
+    } catch (error) {
+      console.error('Notes search error:', error);
+    }
+
+    // Recherche dans l'ontologie
+    try {
+      const entityResults = this.ontology.findEntity({ name: query });
+      for (const entity of entityResults) {
+        results.push({
+          source: 'ontology',
+          type: 'entity',
+          score: 0.9, // Score élevé pour les entités
+          data: entity
+        });
+
+        // Inclut aussi les relations de cette entité
+        const relations = this.ontology.findRelations(entity.id);
+        for (const relation of relations) {
+          results.push({
+            source: 'ontology',
+            type: 'relation',
+            score: 0.7,
+            data: relation
+          });
+        }
+      }
+    } catch (error) {
+      console.error('Ontology search error:', error);
+    }
+
+    // Recherche QMD (vectorielle)
+    try {
+      const qmdResults = await this.qmd.search(query, 5);
+      for (const result of qmdResults) {
+        results.push({
+          source: 'qmd',
+          type: 'file',
+          score: result.score,
+          data: result
+        });
+      }
+    } catch (error) {
+      console.error('QMD search error:', error);
+    }
+
+    // Trie par score décroissant
+    results.sort((a, b) => b.score - a.score);
+
+    return results;
+  }
+
+  /**
+   * Initialise tous les dossiers nécessaires
+   */
+  async init(): Promise<void> {
+    // Crée les dossiers de base
+    if (!existsSync(this.config.memoryDir)) {
+      mkdirSync(this.config.memoryDir, { recursive: true });
+    }
+
+    if (!existsSync(this.config.projectMemoryDir)) {
+      mkdirSync(this.config.projectMemoryDir, { recursive: true });
+    }
+
+    // Initialise QMD si activé
+    if (this.config.qmdEnabled && this.qmd.isAvailable()) {
+      try {
+        await this.qmd.update();
+      } catch (error) {
+        console.error('QMD initialization error:', error);
+      }
+    }
+  }
+
+  /**
+   * Status de tous les sous-systèmes
+   */
+  async status(): Promise<MemoryStatus> {
+    // Status des notes
+    const notesList = this.notes.list();
+    const notesStatus = {
+      count: notesList.length,
+      totalSize: notesList.reduce((sum, note) => sum + note.size, 0),
+      lastModified: notesList.length > 0 ? notesList[0].date : null
+    };
+
+    // Status de l'ontologie
+    const ontologyStats = this.ontology.stats();
+    const ontologyGraph = this.ontology.getGraph();
+    const ontologyStatus = {
+      entities: ontologyGraph.entities.length,
+      relations: ontologyGraph.relations.length,
+      entitiesByType: ontologyStats.entitiesByType,
+      relationsByType: ontologyStats.relationsByType
+    };
+
+    // Status QMD
+    let qmdStatus: MemoryStatus['qmd'] = { available: false };
+    if (this.config.qmdEnabled && this.qmd.isAvailable()) {
+      const status = await this.qmd.status();
+      qmdStatus = {
+        available: true,
+        status: status || { files: 0, chunks: 0, lastUpdate: null }
+      };
+    }
+
+    return {
+      notes: notesStatus,
+      ontology: ontologyStatus,
+      qmd: qmdStatus
+    };
+  }
+
+  /**
+   * Configuration actuelle
+   */
+  getConfig(): MemoryConfig {
+    return { ...this.config };
+  }
+}
+
+// Exports pour une utilisation facile
+export { NotesManager } from './notes.js';
+export { OntologyManager } from './ontology.js';
+export { QMDManager } from './qmd.js';
+export * from './types.js';
+
+// Export par défaut
+export default SigmaMemory;

package/src/notes.ts

@@ -0,0 +1,163 @@
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { execSync } from 'child_process';
+import type { MemoryConfig, Note } from './types.js';
+
+export class NotesManager {
+  private config: MemoryConfig;
+  private notesDir: string;
+
+  constructor(config: MemoryConfig) {
+    this.config = config;
+    this.notesDir = join(config.memoryDir, 'notes');
+    this.ensureDirectories();
+  }
+
+  private ensureDirectories(): void {
+    if (!existsSync(this.config.memoryDir)) {
+      mkdirSync(this.config.memoryDir, { recursive: true });
+    }
+    if (!existsSync(this.notesDir)) {
+      mkdirSync(this.notesDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Écrit dans un fichier .md (date du jour si pas de nom)
+   */
+  write(content: string, filename?: string): void {
+    const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+    const file = filename || `${today}.md`;
+    const filePath = join(this.notesDir, file);
+    
+    writeFileSync(filePath, content, 'utf8');
+  }
+
+  /**
+   * Lit un fichier
+   */
+  read(filename: string): string {
+    const filePath = join(this.notesDir, filename);
+    if (!existsSync(filePath)) {
+      throw new Error(`File not found: ${filename}`);
+    }
+    return readFileSync(filePath, 'utf8');
+  }
+
+  /**
+   * Liste tous les fichiers .md avec leur taille et date
+   */
+  list(): Array<{ name: string; size: number; date: string }> {
+    if (!existsSync(this.notesDir)) {
+      return [];
+    }
+
+    return readdirSync(this.notesDir)
+      .filter(file => file.endsWith('.md'))
+      .map(file => {
+        const filePath = join(this.notesDir, file);
+        const stats = statSync(filePath);
+        return {
+          name: file,
+          size: stats.size,
+          date: stats.mtime.toISOString()
+        };
+      })
+      .sort((a, b) => b.date.localeCompare(a.date));
+  }
+
+  /**
+   * Recherche full-text (grep-like) dans tous les .md
+   */
+  search(query: string): Array<{ file: string; line: number; content: string }> {
+    if (!existsSync(this.notesDir)) {
+      return [];
+    }
+
+    const results: Array<{ file: string; line: number; content: string }> = [];
+    
+    try {
+      // Utilise grep pour une recherche efficace
+      const grepResult = execSync(
+        `grep -n "${query.replace(/"/g, '\\"')}" "${this.notesDir}"/*.md 2>/dev/null || true`,
+        { encoding: 'utf8' }
+      );
+
+      if (grepResult.trim()) {
+        const lines = grepResult.trim().split('\n');
+        for (const line of lines) {
+          const match = line.match(/^(.+?):(\d+):(.+)$/);
+          if (match) {
+            const [, fullPath, lineNumber, content] = match;
+            const filename = fullPath.replace(this.notesDir + '/', '');
+            results.push({
+              file: filename,
+              line: parseInt(lineNumber),
+              content: content.trim()
+            });
+          }
+        }
+      }
+    } catch (error) {
+      // Fallback à une recherche en JavaScript si grep échoue
+      const files = readdirSync(this.notesDir).filter(f => f.endsWith('.md'));
+      for (const file of files) {
+        const filePath = join(this.notesDir, file);
+        const content = readFileSync(filePath, 'utf8');
+        const lines = content.split('\n');
+        
+        lines.forEach((line, index) => {
+          if (line.toLowerCase().includes(query.toLowerCase())) {
+            results.push({
+              file,
+              line: index + 1,
+              content: line.trim()
+            });
+          }
+        });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Retourne les notes des N derniers jours
+   */
+  getRecent(days: number): Note[] {
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - days);
+
+    const files = this.list().filter(file => {
+      const fileDate = new Date(file.date);
+      return fileDate >= cutoffDate;
+    });
+
+    return files.map(file => {
+      const content = this.read(file.name);
+      return {
+        file: file.name,
+        date: file.date,
+        content
+      };
+    });
+  }
+
+  /**
+   * Ajoute à un fichier existant
+   */
+  append(content: string, filename?: string): void {
+    const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+    const file = filename || `${today}.md`;
+    const filePath = join(this.notesDir, file);
+    
+    // Ajoute une ligne vide si le fichier existe déjà et ne se termine pas par une ligne vide
+    if (existsSync(filePath)) {
+      const existingContent = readFileSync(filePath, 'utf8');
+      const separator = existingContent.endsWith('\n') ? '' : '\n';
+      appendFileSync(filePath, separator + content, 'utf8');
+    } else {
+      writeFileSync(filePath, content, 'utf8');
+    }
+  }
+}

package/src/ontology.ts

@@ -0,0 +1,348 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { randomBytes } from 'crypto';
+import type { 
+  MemoryConfig, 
+  OntologyEntity, 
+  OntologyRelation,
+  OntologyJSONLEntry,
+  OntologyEntityEntry,
+  OntologyRelationEntry,
+  OntologyDeleteEntry
+} from './types.js';
+
+export class OntologyManager {
+  private config: MemoryConfig;
+  private graphPath: string;
+  private entities: Map<string, OntologyEntity> = new Map();
+  private relations: Map<string, OntologyRelation> = new Map();
+  private loaded = false;
+
+  constructor(config: MemoryConfig) {
+    this.config = config;
+    this.graphPath = config.ontologyPath;
+    this.ensureDirectories();
+  }
+
+  private ensureDirectories(): void {
+    const dir = dirname(this.graphPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  private generateId(): string {
+    return randomBytes(16).toString('hex');
+  }
+
+  private loadGraph(): void {
+    if (this.loaded) return;
+
+    this.entities.clear();
+    this.relations.clear();
+
+    if (!existsSync(this.graphPath)) {
+      this.loaded = true;
+      return;
+    }
+
+    const content = readFileSync(this.graphPath, 'utf8');
+    const lines = content.trim().split('\n').filter(line => line.trim());
+
+    for (const line of lines) {
+      try {
+        const entry: OntologyJSONLEntry = JSON.parse(line);
+
+        switch (entry.kind) {
+          case 'entity':
+            this.entities.set(entry.id, {
+              id: entry.id,
+              type: entry.type,
+              name: entry.name,
+              properties: entry.properties,
+              createdAt: entry.createdAt,
+              updatedAt: entry.updatedAt
+            });
+            break;
+
+          case 'relation':
+            this.relations.set(entry.id, {
+              id: entry.id,
+              from: entry.from,
+              to: entry.to,
+              type: entry.type,
+              properties: entry.properties,
+              createdAt: entry.createdAt
+            });
+            break;
+
+          case 'delete':
+            // Supprime l'entité ou la relation
+            this.entities.delete(entry.targetId);
+            this.relations.delete(entry.targetId);
+            // Supprime aussi toutes les relations liées à cette entité
+            for (const [relationId, relation] of this.relations) {
+              if (relation.from === entry.targetId || relation.to === entry.targetId) {
+                this.relations.delete(relationId);
+              }
+            }
+            break;
+        }
+      } catch (error) {
+        console.error(`Error parsing JSONL line: ${line}`, error);
+      }
+    }
+
+    this.loaded = true;
+  }
+
+  private appendToFile(entry: OntologyJSONLEntry): void {
+    this.ensureDirectories();
+    const line = JSON.stringify(entry) + '\n';
+    appendFileSync(this.graphPath, line, 'utf8');
+  }
+
+  /**
+   * Ajoute une entité
+   */
+  addEntity(entity: Omit<OntologyEntity, 'id' | 'createdAt' | 'updatedAt'>): string {
+    this.loadGraph();
+
+    const id = this.generateId();
+    const now = new Date().toISOString();
+    
+    const newEntity: OntologyEntity = {
+      ...entity,
+      id,
+      createdAt: now,
+      updatedAt: now
+    };
+
+    this.entities.set(id, newEntity);
+
+    const entry: OntologyEntityEntry = {
+      kind: 'entity',
+      ...newEntity
+    };
+
+    this.appendToFile(entry);
+    return id;
+  }
+
+  /**
+   * Ajoute une relation
+   */
+  addRelation(relation: Omit<OntologyRelation, 'id' | 'createdAt'>): string {
+    this.loadGraph();
+
+    // Vérifie que les entités source et destination existent
+    if (!this.entities.has(relation.from)) {
+      throw new Error(`Source entity not found: ${relation.from}`);
+    }
+    if (!this.entities.has(relation.to)) {
+      throw new Error(`Target entity not found: ${relation.to}`);
+    }
+
+    const id = this.generateId();
+    const now = new Date().toISOString();
+    
+    const newRelation: OntologyRelation = {
+      ...relation,
+      id,
+      createdAt: now
+    };
+
+    this.relations.set(id, newRelation);
+
+    const entry: OntologyRelationEntry = {
+      kind: 'relation',
+      ...newRelation
+    };
+
+    this.appendToFile(entry);
+    return id;
+  }
+
+  /**
+   * Recherche par type/nom
+   */
+  findEntity(query: { type?: string; name?: string }): OntologyEntity[] {
+    this.loadGraph();
+
+    const results: OntologyEntity[] = [];
+    
+    for (const entity of this.entities.values()) {
+      let matches = true;
+
+      if (query.type && entity.type !== query.type) {
+        matches = false;
+      }
+
+      if (query.name && !entity.name.toLowerCase().includes(query.name.toLowerCase())) {
+        matches = false;
+      }
+
+      if (matches) {
+        results.push(entity);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Toutes les relations d'une entité
+   */
+  findRelations(entityId: string): OntologyRelation[] {
+    this.loadGraph();
+
+    const results: OntologyRelation[] = [];
+    
+    for (const relation of this.relations.values()) {
+      if (relation.from === entityId || relation.to === entityId) {
+        results.push(relation);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Retourne le graphe complet
+   */
+  getGraph(): { entities: OntologyEntity[]; relations: OntologyRelation[] } {
+    this.loadGraph();
+
+    return {
+      entities: Array.from(this.entities.values()),
+      relations: Array.from(this.relations.values())
+    };
+  }
+
+  /**
+   * Supprime entité + ses relations
+   */
+  removeEntity(id: string): void {
+    this.loadGraph();
+
+    if (!this.entities.has(id)) {
+      throw new Error(`Entity not found: ${id}`);
+    }
+
+    // Marque comme supprimé dans le fichier
+    const deleteEntry: OntologyDeleteEntry = {
+      kind: 'delete',
+      targetId: id,
+      deletedAt: new Date().toISOString()
+    };
+
+    this.appendToFile(deleteEntry);
+
+    // Supprime de la mémoire
+    this.entities.delete(id);
+    
+    // Supprime toutes les relations liées
+    for (const [relationId, relation] of this.relations) {
+      if (relation.from === id || relation.to === id) {
+        this.relations.delete(relationId);
+      }
+    }
+  }
+
+  /**
+   * Trouve le chemin entre deux entités (BFS)
+   */
+  queryPath(fromId: string, toId: string, maxDepth = 5): Array<{ entity: OntologyEntity; relation?: OntologyRelation }> | null {
+    this.loadGraph();
+
+    if (!this.entities.has(fromId) || !this.entities.has(toId)) {
+      return null;
+    }
+
+    if (fromId === toId) {
+      return [{ entity: this.entities.get(fromId)! }];
+    }
+
+    // BFS pour trouver le chemin le plus court
+    const queue: Array<{ entityId: string; path: Array<{ entity: OntologyEntity; relation?: OntologyRelation }> }> = [
+      { entityId: fromId, path: [{ entity: this.entities.get(fromId)! }] }
+    ];
+    
+    const visited = new Set<string>([fromId]);
+
+    while (queue.length > 0) {
+      const { entityId, path } = queue.shift()!;
+
+      if (path.length > maxDepth) {
+        continue;
+      }
+
+      // Trouve toutes les relations sortantes
+      for (const relation of this.relations.values()) {
+        if (relation.from === entityId) {
+          const targetId = relation.to;
+          
+          if (targetId === toId) {
+            // Trouvé !
+            return [...path, { entity: this.entities.get(targetId)!, relation }];
+          }
+
+          if (!visited.has(targetId)) {
+            visited.add(targetId);
+            queue.push({
+              entityId: targetId,
+              path: [...path, { entity: this.entities.get(targetId)!, relation }]
+            });
+          }
+        }
+
+        // Relations bidirectionnelles (from <-> to)
+        if (relation.to === entityId) {
+          const targetId = relation.from;
+          
+          if (targetId === toId) {
+            // Trouvé !
+            return [...path, { entity: this.entities.get(targetId)!, relation }];
+          }
+
+          if (!visited.has(targetId)) {
+            visited.add(targetId);
+            queue.push({
+              entityId: targetId,
+              path: [...path, { entity: this.entities.get(targetId)!, relation }]
+            });
+          }
+        }
+      }
+    }
+
+    return null; // Aucun chemin trouvé
+  }
+
+  /**
+   * Exporte tout le graphe en JSON lisible
+   */
+  export(): { entities: OntologyEntity[]; relations: OntologyRelation[] } {
+    return this.getGraph();
+  }
+
+  /**
+   * Statistiques : nombre d'entités par type, nombre de relations par type
+   */
+  stats(): { entitiesByType: Record<string, number>; relationsByType: Record<string, number> } {
+    this.loadGraph();
+
+    const entitiesByType: Record<string, number> = {};
+    const relationsByType: Record<string, number> = {};
+
+    for (const entity of this.entities.values()) {
+      entitiesByType[entity.type] = (entitiesByType[entity.type] || 0) + 1;
+    }
+
+    for (const relation of this.relations.values()) {
+      relationsByType[relation.type] = (relationsByType[relation.type] || 0) + 1;
+    }
+
+    return { entitiesByType, relationsByType };
+  }
+}