@afterxleep/doc-bot 1.0.0

package/src/services/InferenceEngine.js

@@ -0,0 +1,207 @@
+const path = require('path');
+
+class InferenceEngine {
+  constructor(documentationService, manifestLoader = null) {
+    this.docService = documentationService;
+    this.manifestLoader = manifestLoader;
+  }
+  
+  async initialize() {
+    // Initialize any required data
+  }
+  
+  async getRelevantDocumentation(context) {
+    try {
+      const globalRules = await this.docService.getGlobalRules();
+      const contextualDocs = await this.getContextualDocs(context);
+      const inferredDocs = await this.getInferredDocs(context);
+      
+      const confidence = this.calculateConfidence(context, contextualDocs, inferredDocs);
+      
+      return {
+        globalRules: globalRules || [],
+        contextualDocs,
+        inferredDocs,
+        confidence
+      };
+    } catch (error) {
+      console.error('Error getting relevant documentation:', error);
+      return {
+        globalRules: [],
+        contextualDocs: [],
+        inferredDocs: [],
+        confidence: 0
+      };
+    }
+  }
+  
+  async getContextualDocs(context) {
+    const docs = [];
+    
+    // Get docs based on file path
+    if (context.filePath) {
+      const pathDocs = await this.docService.getContextualDocs(context.filePath);
+      docs.push(...pathDocs);
+    }
+    
+    return this.removeDuplicates(docs);
+  }
+  
+  async getInferredDocs(context) {
+    const docs = [];
+    
+    // Keyword-based inference
+    if (context.query) {
+      const keywordDocs = await this.getDocsByKeywords(context.query);
+      docs.push(...keywordDocs);
+    }
+    
+    // Pattern-based inference
+    if (context.codeSnippet) {
+      const patternDocs = await this.getDocsByPatterns(context.codeSnippet);
+      docs.push(...patternDocs);
+    }
+    
+    // File extension inference
+    if (context.filePath) {
+      const extensionDocs = await this.getDocsByFileExtension(context.filePath);
+      docs.push(...extensionDocs);
+    }
+    
+    return this.removeDuplicates(docs);
+  }
+  
+  async getDocsByKeywords(query) {
+    if (!this.manifestLoader) {
+      return [];
+    }
+    
+    const manifest = await this.manifestLoader.load();
+    const keywords = manifest.inference?.keywords || {};
+    
+    const docs = [];
+    const queryLower = query.toLowerCase();
+    
+    for (const [keyword, docPaths] of Object.entries(keywords)) {
+      if (queryLower.includes(keyword.toLowerCase())) {
+        for (const docPath of docPaths) {
+          const doc = this.docService.getDocument(docPath);
+          if (doc) {
+            docs.push(doc);
+          }
+        }
+      }
+    }
+    
+    return docs;
+  }
+  
+  async getDocsByPatterns(codeSnippet) {
+    if (!this.manifestLoader) {
+      return [];
+    }
+    
+    const manifest = await this.manifestLoader.load();
+    const patterns = manifest.inference?.patterns || {};
+    
+    const docs = [];
+    
+    for (const [pattern, docPaths] of Object.entries(patterns)) {
+      if (codeSnippet.includes(pattern)) {
+        for (const docPath of docPaths) {
+          const doc = this.docService.getDocument(docPath);
+          if (doc) {
+            docs.push(doc);
+          }
+        }
+      }
+    }
+    
+    return docs;
+  }
+  
+  async getDocsByFileExtension(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const docs = [];
+    
+    // Common patterns for different file types
+    const extensionMappings = {
+      '.js': ['javascript', 'js', 'node'],
+      '.ts': ['typescript', 'ts', 'javascript'],
+      '.jsx': ['react', 'jsx', 'javascript'],
+      '.tsx': ['react', 'tsx', 'typescript'],
+      '.vue': ['vue', 'javascript'],
+      '.py': ['python', 'py'],
+      '.java': ['java'],
+      '.cpp': ['cpp', 'c++'],
+      '.c': ['c', 'cpp'],
+      '.cs': ['csharp', 'c#'],
+      '.rb': ['ruby'],
+      '.go': ['golang', 'go'],
+      '.rs': ['rust'],
+      '.php': ['php'],
+      '.swift': ['swift', 'ios', 'macos'],
+      '.kt': ['kotlin'],
+      '.scala': ['scala'],
+      '.md': ['markdown', 'documentation'],
+      '.css': ['css', 'styling'],
+      '.scss': ['sass', 'scss', 'css'],
+      '.html': ['html', 'web'],
+      '.json': ['json', 'config'],
+      '.yaml': ['yaml', 'config'],
+      '.yml': ['yaml', 'config'],
+      '.xml': ['xml'],
+      '.sql': ['sql', 'database'],
+      '.sh': ['bash', 'shell', 'script'],
+      '.dockerfile': ['docker', 'container'],
+      '.tf': ['terraform', 'infrastructure']
+    };
+    
+    const keywords = extensionMappings[ext] || [];
+    
+    for (const keyword of keywords) {
+      const keywordDocs = await this.docService.searchDocuments(keyword);
+      docs.push(...keywordDocs);
+    }
+    
+    return docs;
+  }
+  
+  calculateConfidence(context, contextualDocs, inferredDocs) {
+    let confidence = 0;
+    
+    // Base confidence from context richness
+    if (context.query) confidence += 0.3;
+    if (context.filePath) confidence += 0.3;
+    if (context.codeSnippet) confidence += 0.2;
+    
+    // Boost confidence based on number of matches
+    if (contextualDocs.length > 0) {
+      confidence += Math.min(contextualDocs.length * 0.1, 0.3);
+    }
+    
+    if (inferredDocs.length > 0) {
+      confidence += Math.min(inferredDocs.length * 0.05, 0.2);
+    }
+    
+    // Reduce confidence if no matches found
+    if (contextualDocs.length === 0 && inferredDocs.length === 0) {
+      confidence *= 0.5;
+    }
+    
+    return Math.min(confidence, 1.0);
+  }
+  
+  removeDuplicates(docs) {
+    const seen = new Set();
+    return docs.filter(doc => {
+      if (seen.has(doc.fileName)) {
+        return false;
+      }
+      seen.add(doc.fileName);
+      return true;
+    });
+  }
+}
+
+module.exports = { InferenceEngine };

package/src/services/ManifestLoader.js

@@ -0,0 +1,135 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class ManifestLoader {
+  constructor(configPath) {
+    this.configPath = configPath;
+    this.manifest = null;
+    this.lastModified = null;
+  }
+  
+  async load() {
+    try {
+      const stats = await fs.stat(this.configPath);
+      
+      // Only reload if file has changed
+      if (this.manifest && this.lastModified && stats.mtime <= this.lastModified) {
+        return this.manifest;
+      }
+      
+      const content = await fs.readFile(this.configPath, 'utf8');
+      this.manifest = JSON.parse(content);
+      this.lastModified = stats.mtime;
+      
+      // Validate manifest structure
+      this.validateManifest();
+      
+      return this.manifest;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // Create default manifest if file doesn't exist
+        this.manifest = this.createDefaultManifest();
+        await this.save();
+        return this.manifest;
+      }
+      throw new Error(`Failed to load manifest: ${error.message}`);
+    }
+  }
+  
+  async reload() {
+    this.manifest = null;
+    this.lastModified = null;
+    return await this.load();
+  }
+  
+  async save() {
+    if (!this.manifest) {
+      throw new Error('No manifest to save');
+    }
+    
+    await fs.ensureDir(path.dirname(this.configPath));
+    await fs.writeJSON(this.configPath, this.manifest, { spaces: 2 });
+  }
+  
+  validateManifest() {
+    if (!this.manifest) {
+      throw new Error('Manifest is null');
+    }
+    
+    // Required fields
+    if (!this.manifest.name) {
+      this.manifest.name = 'Project Documentation';
+    }
+    
+    if (!this.manifest.version) {
+      this.manifest.version = '1.0.0';
+    }
+    
+    // Optional fields with defaults
+    if (!this.manifest.globalRules) {
+      this.manifest.globalRules = [];
+    }
+    
+    if (!this.manifest.contextualRules) {
+      this.manifest.contextualRules = {};
+    }
+    
+    if (!this.manifest.inference) {
+      this.manifest.inference = {
+        keywords: {},
+        patterns: {}
+      };
+    }
+    
+    // Validate globalRules is array
+    if (!Array.isArray(this.manifest.globalRules)) {
+      throw new Error('globalRules must be an array');
+    }
+    
+    // Validate contextualRules is object
+    if (typeof this.manifest.contextualRules !== 'object') {
+      throw new Error('contextualRules must be an object');
+    }
+    
+    // Validate inference structure
+    if (!this.manifest.inference.keywords) {
+      this.manifest.inference.keywords = {};
+    }
+    
+    if (!this.manifest.inference.patterns) {
+      this.manifest.inference.patterns = {};
+    }
+  }
+  
+  createDefaultManifest() {
+    return {
+      name: 'Project Documentation',
+      version: '1.0.0',
+      description: 'AI-powered documentation',
+      globalRules: [],
+      contextualRules: {},
+      inference: {
+        keywords: {},
+        patterns: {}
+      }
+    };
+  }
+  
+  getManifest() {
+    return this.manifest;
+  }
+  
+  getGlobalRules() {
+    return this.manifest?.globalRules || [];
+  }
+  
+  getContextualRules() {
+    return this.manifest?.contextualRules || {};
+  }
+  
+  getInferenceConfig() {
+    return this.manifest?.inference || { keywords: {}, patterns: {} };
+  }
+}
+
+module.exports = { ManifestLoader };