scene-capability-engine 3.0.0

package/lib/knowledge/entry-manager.js

@@ -0,0 +1,208 @@
+/**
+ * Entry Manager
+ * Handles knowledge entry file operations
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const yaml = require('js-yaml');
+
+class EntryManager {
+  constructor(knowledgePath) {
+    this.knowledgePath = knowledgePath;
+  }
+  
+  /**
+   * Create new entry
+   * @param {string} type - Entry type
+   * @param {string} title - Entry title
+   * @param {string} content - Entry content
+   * @param {Object} metadata - Entry metadata
+   * @returns {Object} - Created entry info
+   */
+  async create(type, title, content, metadata) {
+    const id = this.generateId();
+    const filename = this.generateFilename(type, title);
+    const filePath = path.join(this.knowledgePath, `${type}s`, filename);
+    
+    const fullMetadata = {
+      id,
+      type,
+      title,
+      created: new Date().toISOString(),
+      updated: new Date().toISOString(),
+      tags: metadata.tags || [],
+      category: metadata.category || null,
+      status: 'active',
+      integration: null,
+      ...metadata
+    };
+    
+    const fileContent = this.serializeFrontmatter(fullMetadata, content);
+    
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, fileContent, 'utf-8');
+    
+    return {
+      id,
+      file: path.relative(this.knowledgePath, filePath),
+      path: filePath
+    };
+  }
+  
+  /**
+   * Read entry
+   * @param {string} filePath - Entry file path
+   * @returns {Object} - Entry data
+   */
+  async read(filePath) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    return this.parseFrontmatter(content);
+  }
+  
+  /**
+   * Update entry
+   * @param {string} filePath - Entry file path
+   * @param {string} content - New content
+   * @param {Object} metadata - Updated metadata
+   */
+  async update(filePath, content, metadata) {
+    const existing = await this.read(filePath);
+    
+    const updatedMetadata = {
+      ...existing.metadata,
+      ...metadata,
+      updated: new Date().toISOString()
+    };
+    
+    const fileContent = this.serializeFrontmatter(updatedMetadata, content || existing.content);
+    await fs.writeFile(filePath, fileContent, 'utf-8');
+  }
+  
+  /**
+   * Delete entry
+   * @param {string} filePath - Entry file path
+   * @param {boolean} backup - Create backup before deletion
+   */
+  async delete(filePath, backup = true) {
+    if (backup) {
+      const backupDir = path.join(this.knowledgePath, '.backups');
+      await fs.ensureDir(backupDir);
+      
+      const timestamp = Date.now();
+      const basename = path.basename(filePath);
+      const backupPath = path.join(backupDir, `${timestamp}-${basename}`);
+      
+      await fs.copy(filePath, backupPath);
+    }
+    
+    await fs.remove(filePath);
+  }
+  
+  /**
+   * Check if entry exists
+   * @param {string} filePath - Entry file path
+   * @returns {boolean}
+   */
+  async exists(filePath) {
+    return fs.pathExists(filePath);
+  }
+  
+  /**
+   * Parse frontmatter from content
+   * @param {string} content - File content
+   * @returns {Object} - Parsed data
+   */
+  parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    
+    if (!match) {
+      throw new Error('Invalid entry format: missing frontmatter');
+    }
+    
+    const [, frontmatter, body] = match;
+    
+    try {
+      const metadata = yaml.load(frontmatter);
+      return {
+        metadata,
+        content: body.trim()
+      };
+    } catch (error) {
+      throw new Error(`Invalid YAML frontmatter: ${error.message}`);
+    }
+  }
+  
+  /**
+   * Serialize frontmatter and content
+   * @param {Object} metadata - Entry metadata
+   * @param {string} content - Entry content
+   * @returns {string} - Serialized content
+   */
+  serializeFrontmatter(metadata, content) {
+    const frontmatter = yaml.dump(metadata, {
+      indent: 2,
+      lineWidth: -1
+    });
+    
+    return `---\n${frontmatter}---\n\n${content}`;
+  }
+  
+  /**
+   * Validate entry structure
+   * @param {string} filePath - Entry file path
+   * @returns {Object} - Validation result
+   */
+  async validate(filePath) {
+    try {
+      const data = await this.read(filePath);
+      const { metadata } = data;
+      
+      const errors = [];
+      
+      if (!metadata.id) errors.push('Missing id');
+      if (!metadata.type) errors.push('Missing type');
+      if (!metadata.title) errors.push('Missing title');
+      if (!metadata.created) errors.push('Missing created date');
+      if (!metadata.updated) errors.push('Missing updated date');
+      if (!metadata.status) errors.push('Missing status');
+      
+      return {
+        valid: errors.length === 0,
+        errors
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [error.message]
+      };
+    }
+  }
+  
+  /**
+   * Generate unique ID
+   * @returns {string} - Unique ID
+   */
+  generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 8);
+    return `kb-${timestamp}-${random}`;
+  }
+  
+  /**
+   * Generate filename from title
+   * @param {string} type - Entry type
+   * @param {string} title - Entry title
+   * @returns {string} - Kebab-case filename
+   */
+  generateFilename(type, title) {
+    const kebab = title
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '');
+    
+    return `${kebab}.md`;
+  }
+}
+
+module.exports = EntryManager;

package/lib/knowledge/index-manager.js

@@ -0,0 +1,261 @@
+/**
+ * Index Manager
+ * Manages knowledge base index for fast lookups
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+class IndexManager {
+  constructor(knowledgePath) {
+    this.knowledgePath = knowledgePath;
+    this.indexPath = path.join(knowledgePath, 'index.json');
+    this.index = null;
+  }
+  
+  /**
+   * Load index from file
+   * @returns {Object} - Index data
+   */
+  async load() {
+    if (this.index) {
+      return this.index;
+    }
+    
+    if (await fs.pathExists(this.indexPath)) {
+      try {
+        this.index = await fs.readJson(this.indexPath);
+        return this.index;
+      } catch (error) {
+        throw new Error(`Failed to load index: ${error.message}`);
+      }
+    }
+    
+    // Initialize empty index
+    this.index = {
+      version: '1.0.0',
+      entries: [],
+      stats: {
+        totalEntries: 0,
+        byType: {},
+        byStatus: {},
+        byTag: {}
+      },
+      lastUpdated: new Date().toISOString()
+    };
+    
+    return this.index;
+  }
+  
+  /**
+   * Save index to file
+   */
+  async save() {
+    if (!this.index) {
+      throw new Error('Index not loaded');
+    }
+    
+    this.index.lastUpdated = new Date().toISOString();
+    await fs.writeJson(this.indexPath, this.index, { spaces: 2 });
+  }
+  
+  /**
+   * Add entry to index
+   * @param {Object} metadata - Entry metadata
+   */
+  async addEntry(metadata) {
+    await this.load();
+    
+    const entry = {
+      id: metadata.id,
+      type: metadata.type,
+      title: metadata.title,
+      file: metadata.file,
+      created: metadata.created,
+      updated: metadata.updated,
+      tags: metadata.tags || [],
+      category: metadata.category || null,
+      status: metadata.status || 'active',
+      integration: metadata.integration || null
+    };
+    
+    this.index.entries.push(entry);
+    this._updateStats();
+    await this.save();
+  }
+  
+  /**
+   * Update entry in index
+   * @param {string} id - Entry ID
+   * @param {Object} updates - Updates to apply
+   */
+  async updateEntry(id, updates) {
+    await this.load();
+    
+    const entry = this.index.entries.find(e => e.id === id);
+    if (!entry) {
+      throw new Error(`Entry not found: ${id}`);
+    }
+    
+    Object.assign(entry, updates);
+    entry.updated = new Date().toISOString();
+    
+    this._updateStats();
+    await this.save();
+  }
+  
+  /**
+   * Remove entry from index
+   * @param {string} id - Entry ID
+   */
+  async removeEntry(id) {
+    await this.load();
+    
+    const index = this.index.entries.findIndex(e => e.id === id);
+    if (index === -1) {
+      throw new Error(`Entry not found: ${id}`);
+    }
+    
+    this.index.entries.splice(index, 1);
+    this._updateStats();
+    await this.save();
+  }
+  
+  /**
+   * Find entry by ID
+   * @param {string} id - Entry ID
+   * @returns {Object|null} - Entry or null
+   */
+  async findById(id) {
+    await this.load();
+    return this.index.entries.find(e => e.id === id) || null;
+  }
+  
+  /**
+   * Find entries by type
+   * @param {string} type - Entry type
+   * @returns {Array} - Matching entries
+   */
+  async findByType(type) {
+    await this.load();
+    return this.index.entries.filter(e => e.type === type);
+  }
+  
+  /**
+   * Find entries by tag
+   * @param {string} tag - Tag name
+   * @returns {Array} - Matching entries
+   */
+  async findByTag(tag) {
+    await this.load();
+    return this.index.entries.filter(e => e.tags.includes(tag));
+  }
+  
+  /**
+   * Search entries by keyword
+   * @param {string} keyword - Search keyword
+   * @returns {Array} - Matching entries
+   */
+  async search(keyword) {
+    await this.load();
+    
+    const lowerKeyword = keyword.toLowerCase();
+    
+    return this.index.entries.filter(entry => {
+      return (
+        entry.title.toLowerCase().includes(lowerKeyword) ||
+        entry.tags.some(tag => tag.toLowerCase().includes(lowerKeyword)) ||
+        (entry.category && entry.category.toLowerCase().includes(lowerKeyword))
+      );
+    });
+  }
+  
+  /**
+   * Get statistics
+   * @returns {Object} - Statistics
+   */
+  async getStats() {
+    await this.load();
+    return this.index.stats;
+  }
+  
+  /**
+   * Rebuild index from files
+   */
+  async rebuild() {
+    const EntryManager = require('./entry-manager');
+    const entryManager = new EntryManager(this.knowledgePath);
+    
+    this.index = {
+      version: '1.0.0',
+      entries: [],
+      stats: {
+        totalEntries: 0,
+        byType: {},
+        byStatus: {},
+        byTag: {}
+      },
+      lastUpdated: new Date().toISOString()
+    };
+    
+    const types = ['pattern', 'lesson', 'workflow', 'checklist', 'reference'];
+    
+    for (const type of types) {
+      const typeDir = path.join(this.knowledgePath, `${type}s`);
+      
+      if (await fs.pathExists(typeDir)) {
+        const files = await fs.readdir(typeDir);
+        
+        for (const file of files) {
+          if (file.endsWith('.md')) {
+            const filePath = path.join(typeDir, file);
+            
+            try {
+              const data = await entryManager.read(filePath);
+              const { metadata } = data;
+              
+              await this.addEntry({
+                ...metadata,
+                file: path.relative(this.knowledgePath, filePath)
+              });
+            } catch (error) {
+              console.warn(`Failed to read ${file}: ${error.message}`);
+            }
+          }
+        }
+      }
+    }
+    
+    await this.save();
+  }
+  
+  /**
+   * Update statistics
+   * @private
+   */
+  _updateStats() {
+    const stats = {
+      totalEntries: this.index.entries.length,
+      byType: {},
+      byStatus: {},
+      byTag: {}
+    };
+    
+    for (const entry of this.index.entries) {
+      // Count by type
+      stats.byType[entry.type] = (stats.byType[entry.type] || 0) + 1;
+      
+      // Count by status
+      stats.byStatus[entry.status] = (stats.byStatus[entry.status] || 0) + 1;
+      
+      // Count by tag
+      for (const tag of entry.tags) {
+        stats.byTag[tag] = (stats.byTag[tag] || 0) + 1;
+      }
+    }
+    
+    this.index.stats = stats;
+  }
+}
+
+module.exports = IndexManager;