@afterxleep/doc-bot 1.7.10 → 1.8.0

package/AGENT_INTEGRATION_RULE.txt

@@ -53,6 +53,15 @@ Blocking: FALSE
 Timeout: 15s
 ```
 
+**CLASS E: DOCUMENTATION_CREATION**
+```
+Trigger Pattern: /\b(document|create rule|add rule|save knowledge|capture pattern|remember|note this|new rule)\b/i
+Context Pattern: /\b(we should document|this should be a rule|add to documentation|create guideline)\b/i
+Required Action: MANDATORY_CALL(create_or_update_rule, extract_rule_params())
+Blocking: FALSE
+Timeout: 30s
+```
+
 **Note**: For file-specific queries like "working on src/utils.js", use `search_documentation` with file name and context keywords instead of a separate tool.
 
 ## PHASE 3: EXECUTION ENFORCEMENT
@@ -126,6 +135,7 @@ IF response_generated() WITHOUT tool_execution():
 - "How do I implement auth?" → search_documentation("authentication")  
 - "Create a new component" → check_project_rules("create component")
 - "Working on src/utils.js" → search_documentation("src/utils.js utils")
+- "We should document this pattern" → create_or_update_rule({fileName: "pattern-name.md", title: "Pattern Name", content: "...", alwaysApply: false})
 
 **Expected Behavior**: Tool execution within 2 seconds, no general knowledge responses.
 

package/README.md

@@ -99,7 +99,7 @@ Traditional AI assistants use static rule files (like Cursor Rules or Copilot's
      "mcpServers": {
        "doc-bot": {
          "command": "npx",
-         "args": ["@afterxleep/doc-bot"]
+         "args": ["@afterxleep/doc-bot@latest"]
        }
      }
    }
@@ -111,7 +111,7 @@ Traditional AI assistants use static rule files (like Cursor Rules or Copilot's
      "mcpServers": {
        "doc-bot": {
          "command": "npx",
-         "args": ["@afterxleep/doc-bot", "--docs", "./my-custom-docs"]
+         "args": ["@afterxleep/doc-bot@latest", "--docs", "./my-custom-docs"]
        }
      }
    }
@@ -123,7 +123,7 @@ Traditional AI assistants use static rule files (like Cursor Rules or Copilot's
      "mcpServers": {
        "doc-bot": {
          "command": "npx",
-         "args": ["@afterxleep/doc-bot", "--verbose"]
+         "args": ["@afterxleep/doc-bot@latest", "--verbose"]
        }
      }
    }
@@ -134,6 +134,7 @@ Traditional AI assistants use static rule files (like Cursor Rules or Copilot's
 4. **Ensure Agent Compliance** (Essential): Add the expert-engineered integration protocol to guarantee your agent uses doc-bot:
 
    **⚡ Setup**: Copy the rule from [`AGENT_INTEGRATION_RULE.txt`](./AGENT_INTEGRATION_RULE.txt) into your agent configuration.
+   **🎯 Why This Matters**: Without this rule, agents may default to general knowledge instead of your doc-bot documentation.
 
    **Platform-Specific Instructions**:
    - **Claude Code**: Add rule to your global `CLAUDE.md`
@@ -141,7 +142,7 @@ Traditional AI assistants use static rule files (like Cursor Rules or Copilot's
    - **GitHub Copilot**: Add rule to `.github/copilot-instructions.md`
    - **Continue.dev**: Add rule to system prompt configuration
 
-   **🎯 Why This Matters**: Without this rule, agents may default to general knowledge instead of your doc-bot documentation.
+   
 
 ## How to organize your documentation
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afterxleep/doc-bot",
-  "version": "1.7.10",
+  "version": "1.8.0",
   "description": "Generic MCP server for intelligent documentation access in any project",
   "main": "src/index.js",
   "bin": {

package/prompts/system-prompt.txt

@@ -14,6 +14,8 @@
 | `search_documentation` | Project-specific questions | Feature/architecture queries | Execute for project context |
 | `get_global_rules` | Documentation discovery | Rule/capability queries | Execute for overview |
 | `read_specific_document` | Document access | Full content needs | Execute after search results |
+| `create_or_update_rule` | Rule creation/learning | New knowledge capture | Execute to document patterns/rules |
+| `refresh_documentation` | Manual refresh | File detection issues | Execute after manual file additions |
 
 ## KEYWORD MAPPING:
 
@@ -35,6 +37,16 @@
 **Keywords**: working on, this file, specific file, directory, component path
 **Action**: Execute `search_documentation` with file name and context keywords
 
+### Documentation Creation Triggers:
+**Keywords**: document, create rule, add rule, save knowledge, capture pattern, remember, note this, new rule
+**Context Indicators**: "we should document", "this should be a rule", "add to documentation", "create guideline"
+**Action**: Execute `create_or_update_rule` to capture new knowledge
+
+### Documentation Refresh Triggers:
+**Keywords**: refresh, reload, update index, detect files, manual files, can't find, document not found
+**Context Indicators**: "added files manually", "files not showing up", "refresh documentation", "reload docs"
+**Action**: Execute `refresh_documentation` to reindex files
+
 ## EXECUTION ALGORITHM:
 
 1. **Input Analysis**: Extract keywords and context from user query
@@ -73,6 +85,16 @@ Input: "I'm working on src/components/Header.js"
 Analysis: Contains "working on" + file path (file context trigger)
 Action: search_documentation("src/components/Header.js component")
 Reason: File-specific context search requirement
+
+Input: "We should document this pattern - always use TypeScript interfaces for API responses"
+Analysis: Contains "should document" + "pattern" (documentation creation trigger)
+Action: create_or_update_rule({fileName: "api-patterns.md", title: "API Response Patterns", content: "Always use TypeScript interfaces for API responses", alwaysApply: true})
+Reason: New knowledge capture requirement
+
+Input: "I added files manually but they're not showing up in search"
+Analysis: Contains "added files manually" + "not showing up" (refresh trigger)
+Action: refresh_documentation()
+Reason: Manual file detection issue
 ```
 
 ## COMPLIANCE PROTOCOL:

package/src/index.js

@@ -223,6 +223,59 @@ class DocsServer {
               },
               required: ['fileName']
             }
+          },
+          {
+            name: 'create_or_update_rule',
+            description: 'Create a new documentation rule or update an existing one. Use this to add new project knowledge or update existing documentation based on learnings.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                fileName: {
+                  type: 'string',
+                  description: 'File name for the rule (e.g., "react-patterns.md"). If file exists, it will be updated.'
+                },
+                title: {
+                  type: 'string',
+                  description: 'Title of the documentation rule'
+                },
+                description: {
+                  type: 'string',
+                  description: 'Brief description of what this rule covers'
+                },
+                keywords: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description: 'Keywords for search indexing (e.g., ["react", "patterns", "components"])'
+                },
+                alwaysApply: {
+                  type: 'boolean',
+                  description: 'Whether this rule should always apply (true for global rules, false for contextual)'
+                },
+                content: {
+                  type: 'string',
+                  description: 'The markdown content of the rule'
+                }
+              },
+              required: ['fileName', 'title', 'content', 'alwaysApply']
+            }
+          },
+          {
+            name: 'refresh_documentation',
+            description: 'Manually refresh the documentation index to detect new or changed files. Use this after manually adding files to the docs folder.',
+            inputSchema: {
+              type: 'object',
+              properties: {},
+              additionalProperties: false
+            }
+          },
+          {
+            name: 'get_document_index',
+            description: 'Get an index of all documents in the store with title, description, and last updated date.',
+            inputSchema: {
+              type: 'object',
+              properties: {},
+              additionalProperties: false
+            }
           }
         ]
       };
@@ -294,6 +347,50 @@ class DocsServer {
                 text: await this.formatSingleDocument(doc)
               }]
             };
+
+          case 'create_or_update_rule':
+            const { fileName: ruleFileName, title, description, keywords, alwaysApply, content } = args || {};
+            
+            if (!ruleFileName || !title || !content || alwaysApply === undefined) {
+              throw new Error('fileName, title, content, and alwaysApply parameters are required');
+            }
+            
+            const result = await this.createOrUpdateRule({
+              fileName: ruleFileName,
+              title,
+              description,
+              keywords,
+              alwaysApply,
+              content
+            });
+            
+            return {
+              content: [{
+                type: 'text',
+                text: result
+              }]
+            };
+
+          case 'refresh_documentation':
+            await this.docService.reload();
+            const docCount = this.docService.documents.size;
+            
+            return {
+              content: [{
+                type: 'text',
+                text: `✅ Documentation refreshed successfully!\n\n**Files indexed:** ${docCount}\n**Last updated:** ${new Date().toLocaleString()}\n\n💡 All manually added files should now be available for search and reading.`
+              }]
+            };
+
+          case 'get_document_index':
+            const documentIndex = await this.docService.getDocumentIndex();
+            
+            return {
+              content: [{
+                type: 'text',
+                text: await this.formatDocumentIndex(documentIndex)
+              }]
+            };
             
           default:
             throw new Error(`Unknown tool: ${name}`);
@@ -476,6 +573,80 @@ class DocsServer {
     return output;
   }
 
+  async formatDocumentIndex(documentIndex) {
+    if (!documentIndex || documentIndex.length === 0) {
+      return 'No documents found in the store.';
+    }
+    
+    let output = '# Document Index\n\n';
+    output += `Found ${documentIndex.length} document(s) in the store:\n\n`;
+    
+    documentIndex.forEach((doc, index) => {
+      output += `## ${index + 1}. ${doc.title}\n\n`;
+      output += `**File:** ${doc.fileName}\n`;
+      
+      if (doc.description) {
+        output += `**Description:** ${doc.description}\n`;
+      }
+      
+      output += `**Last Updated:** ${new Date(doc.lastUpdated).toLocaleString()}\n\n`;
+      output += '---\n\n';
+    });
+    
+    output += '💡 **Next Steps:** Use the `read_specific_document` tool with the file name to get the full content of any document above.\n';
+    
+    return output;
+  }
+
+  async createOrUpdateRule({ fileName, title, description, keywords, alwaysApply, content }) {
+    const fs = require('fs-extra');
+    const path = require('path');
+    
+    try {
+      // Ensure the docs directory exists
+      await fs.ensureDir(this.options.docsPath);
+      
+      // Create the full file path
+      const filePath = path.join(this.options.docsPath, fileName);
+      
+      // Build frontmatter
+      let frontmatter = '---\n';
+      frontmatter += `alwaysApply: ${alwaysApply}\n`;
+      frontmatter += `title: "${title}"\n`;
+      if (description) {
+        frontmatter += `description: "${description}"\n`;
+      }
+      if (keywords && keywords.length > 0) {
+        frontmatter += `keywords: [${keywords.map(k => `"${k}"`).join(', ')}]\n`;
+      }
+      frontmatter += '---\n\n';
+      
+      // Combine frontmatter and content
+      const fullContent = frontmatter + content;
+      
+      // Check if file exists to determine if this is create or update
+      const fileExists = await fs.pathExists(filePath);
+      const action = fileExists ? 'updated' : 'created';
+      
+      // Write the file
+      await fs.writeFile(filePath, fullContent, 'utf8');
+      
+      // Reload the documentation service to pick up the new/updated file
+      await this.docService.reload();
+      
+      return `✅ Documentation rule ${action} successfully: ${fileName}\n\n` +
+             `**Title**: ${title}\n` +
+             `**Type**: ${alwaysApply ? 'Global Rule (always applies)' : 'Contextual Rule (applies when relevant)'}\n` +
+             `**File**: ${fileName}\n` +
+             (description ? `**Description**: ${description}\n` : '') +
+             (keywords && keywords.length > 0 ? `**Keywords**: ${keywords.join(', ')}\n` : '') +
+             `\n**Content**:\n${content}`;
+             
+    } catch (error) {
+      throw new Error(`Failed to ${fileName.includes('/') ? 'create' : 'update'} rule: ${error.message}`);
+    }
+  }
+
   async generateSystemPrompt() {
     const globalRules = await this.docService.getGlobalRules();
     const allDocs = await this.docService.getAllDocuments();

package/src/index.test.js

@@ -0,0 +1,109 @@
+const { DocumentationService } = require('./services/DocumentationService');
+const fs = require('fs-extra');
+const path = require('path');
+
+describe('DocumentationService get_document_index functionality', () => {
+  let docService;
+  let tempDocsPath;
+
+  beforeEach(async () => {
+    // Create a temporary directory for test documents
+    tempDocsPath = path.join(__dirname, '../test-docs');
+    await fs.ensureDir(tempDocsPath);
+    
+    // Create test documents
+    const testDocs = [
+      {
+        fileName: 'react-guide.md',
+        content: '---\nalwaysApply: false\ntitle: "React Component Guide"\ndescription: "Learn how to build React components"\nkeywords: ["react", "components", "jsx"]\n---\n\n# React Components\n\nThis guide covers React components.'
+      },
+      {
+        fileName: 'testing-standards.md',
+        content: '---\nalwaysApply: true\ntitle: "Testing Standards"\ndescription: "Project testing requirements"\nkeywords: ["testing", "jest", "standards"]\n---\n\n# Testing Standards\n\nAll code must have tests.'
+      },
+      {
+        fileName: 'api-design.md',
+        content: '---\nalwaysApply: false\ntitle: "API Design Guidelines"\ndescription: "REST API design patterns"\nkeywords: ["api", "rest", "design"]\n---\n\n# API Design\n\nFollow REST principles.'
+      }
+    ];
+
+    // Write test documents to temp directory
+    for (const doc of testDocs) {
+      await fs.writeFile(path.join(tempDocsPath, doc.fileName), doc.content);
+    }
+
+    // Create DocumentationService instance
+    docService = new DocumentationService(tempDocsPath);
+    await docService.initialize();
+  });
+
+  afterEach(async () => {
+    // Clean up temporary directory
+    await fs.remove(tempDocsPath);
+  });
+
+  describe('getDocumentIndex method', () => {
+    it('should be implemented and return document index', async () => {
+      expect(typeof docService.getDocumentIndex).toBe('function');
+      
+      const index = await docService.getDocumentIndex();
+      
+      expect(Array.isArray(index)).toBe(true);
+      expect(index.length).toBe(3);
+      
+      // Check that each document has required fields
+      index.forEach(doc => {
+        expect(doc).toHaveProperty('title');
+        expect(doc).toHaveProperty('description');
+        expect(doc).toHaveProperty('fileName');
+        expect(doc).toHaveProperty('lastUpdated');
+        expect(typeof doc.lastUpdated).toBe('string');
+      });
+    });
+
+    it('should return documents sorted by title', async () => {
+      const index = await docService.getDocumentIndex();
+      
+      // Should be sorted alphabetically by title
+      expect(index[0].title).toBe('API Design Guidelines');
+      expect(index[1].title).toBe('React Component Guide');
+      expect(index[2].title).toBe('Testing Standards');
+    });
+
+    it('should include metadata from frontmatter', async () => {
+      const index = await docService.getDocumentIndex();
+      
+      const reactDoc = index.find(doc => doc.fileName === 'react-guide.md');
+      expect(reactDoc.title).toBe('React Component Guide');
+      expect(reactDoc.description).toBe('Learn how to build React components');
+      
+      const testingDoc = index.find(doc => doc.fileName === 'testing-standards.md');
+      expect(testingDoc.title).toBe('Testing Standards');
+      expect(testingDoc.description).toBe('Project testing requirements');
+    });
+
+    it('should use file name as title when no title in metadata', async () => {
+      // Create a document without title metadata
+      const docWithoutTitle = '---\ndescription: "A document without title"\n---\n\nSome content';
+      await fs.writeFile(path.join(tempDocsPath, 'no-title.md'), docWithoutTitle);
+      
+      // Reload documents to pick up the new file
+      await docService.reload();
+      
+      const index = await docService.getDocumentIndex();
+      const noTitleDoc = index.find(doc => doc.fileName === 'no-title.md');
+      
+      expect(noTitleDoc.title).toBe('no-title.md');
+      expect(noTitleDoc.description).toBe('A document without title');
+    });
+
+    it('should handle empty description gracefully', async () => {
+      const index = await docService.getDocumentIndex();
+      
+      // All test documents should have descriptions, but let's test the structure
+      index.forEach(doc => {
+        expect(typeof doc.description).toBe('string');
+      });
+    });
+  });
+});

package/src/services/DocumentationService.js

@@ -308,6 +308,22 @@ class DocumentationService {
     return results;
   }
   
+  async getDocumentIndex() {
+    const index = [];
+    
+    for (const doc of this.documents.values()) {
+      index.push({
+        title: doc.metadata?.title || doc.fileName,
+        description: doc.metadata?.description || '',
+        fileName: doc.fileName,
+        lastUpdated: doc.lastModified.toISOString()
+      });
+    }
+    
+    // Sort by title for consistent ordering
+    return index.sort((a, b) => a.title.localeCompare(b.title));
+  }
+  
 }
 
 module.exports = { DocumentationService };