@afterxleep/doc-bot 1.7.10 → 1.7.11

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

@@ -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.7.11",
   "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,50 @@ 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
+            }
           }
         ]
       };
@@ -294,6 +338,40 @@ 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.`
+              }]
+            };
             
           default:
             throw new Error(`Unknown tool: ${name}`);
@@ -476,6 +554,55 @@ class DocsServer {
     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();