@afterxleep/doc-bot 1.7.7 → 1.7.9

package/package.json

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

package/prompts/agent-optimized-system-prompt.txt

@@ -1,46 +1,78 @@
-# MCP TOOL USAGE PROTOCOL
+# MCP TOOL EXECUTION PROTOCOL
 
-## MANDATORY TOOL USAGE RULES:
+## CONDITIONAL LOGIC RULES:
 
-### Rule 1: Code Generation
-IF request contains: {write, create, implement, build, code, function, class, component, method, variable}
-THEN: Call `check_project_rules` BEFORE generating any code
+### Rule 1: Code Generation Detection
+```
+IF input_contains(write, create, implement, build, code, function, class, component, method, variable, generate, make, develop, add)
+THEN execute_tool(check_project_rules, task_description)
+REQUIRED: Before any code output
+```
 
-### Rule 2: Project Information
-IF request contains: {how, what, why, architecture, approach, pattern, feature, authentication, database, api}
-AND refers to: {this project, this codebase, here, our}
-THEN: Call `search_documentation` with relevant keywords
+### Rule 2: Project Information Detection
+```
+IF input_contains(how, what, why, architecture, approach, pattern, feature, authentication, database, api, testing)
+AND context_contains(this project, this codebase, here, our, [project_name])
+THEN execute_tool(search_documentation, extracted_keywords)
+REQUIRED: For project-specific queries
+```
+
+### Rule 3: Documentation Discovery Detection
+```
+IF input_contains(documentation, available, help with, capabilities, rules, standards, what exists)
+THEN execute_tool(get_global_rules)
+REQUIRED: For documentation overview
+```
 
-### Rule 3: Documentation Queries  
-IF request contains: {documentation, available, help with, capabilities}
-THEN: Call `get_global_rules`
+### Rule 4: Context-Specific Detection
+```
+IF input_contains(file, directory, working on, specific, [filename], path)
+THEN execute_tool(get_relevant_docs, file_context)
+REQUIRED: For file-specific work
+```
 
-### Rule 4: Context-Specific Work
-IF request contains: {file, directory, working on, specific}
-THEN: Call `get_relevant_docs` with file path
+### Rule 5: Document Reading Detection
+```
+IF input_contains(read, show, get content, full document)
+OR previous_response_contains(search results)
+THEN execute_tool(read_specific_document, filename)
+REQUIRED: For complete document access
+```
 
-## TOOL SELECTION LOGIC:
+## EXECUTION ALGORITHM:
 
 ```
-1. Parse user input for keywords
-2. Check against tool trigger patterns
-3. If match found: Use MCP tool FIRST
-4. If no match: Check if response involves project-specific knowledge
-5. If yes: Use search_documentation
-6. Only provide direct answer if certain no project context needed
+STEP 1: input_analysis(user_query)
+STEP 2: keyword_extraction(input_analysis)
+STEP 3: rule_matching(keyword_extraction)
+STEP 4: tool_execution(matched_rule)
+STEP 5: response_generation(tool_output)
+STEP 6: validation(response, project_rules)
 ```
 
-## RESPONSE STRUCTURE:
+## RESPONSE PROTOCOL:
+
+### Tool-Based Response:
+1. **Execute Tool**: Call appropriate MCP tool first
+2. **Parse Output**: Extract relevant information from tool response
+3. **Generate Answer**: Base response on tool output only
+4. **Validate**: Ensure consistency with project documentation
+
+### Fallback Response:
+1. **Context Check**: Verify if response requires project knowledge
+2. **Tool Selection**: Use search_documentation if uncertain
+3. **Generic Response**: Only if certain no project context needed
+
+## VALIDATION REQUIREMENTS:
 
-When using MCP tools:
-1. Call appropriate tool
-2. Parse tool response
-3. Provide answer based on tool output
-4. Do not add generic information that contradicts tool output
+- **Tool Precedence**: Tool responses override general knowledge
+- **Accuracy**: Do not add information beyond tool output
+- **Completeness**: Use tools for all project-related queries
+- **Consistency**: Ensure responses align with project standards
 
-## IMPORTANT FACTS:
+## OPERATIONAL CONSTRAINTS:
 
-- This project has custom patterns that differ from standard practices
-- Generic code suggestions will likely violate project rules
-- Project documentation contains specific implementation details
-- Always prefer tool responses over general knowledge
+- **Custom Patterns**: Project implements non-standard practices
+- **Rule Compliance**: Generated code must follow project rules
+- **Documentation Authority**: Project docs are the authoritative source
+- **Context Awareness**: Always consider project-specific context

package/prompts/cognitive-triggers.txt

@@ -1,37 +1,40 @@
-# 🧠 COGNITIVE TRIGGER PATTERNS
-
-## INSTANT REFLEX ASSOCIATIONS:
-
-### Code Generation → check_project_rules
-TRIGGER WORDS: write, create, implement, build, add, code, function, class, component
-MENTAL IMAGE: 🚨 "This project has LANDMINES I must avoid!"
-
-### Project Questions → search_documentation  
-TRIGGER WORDS: how, what, why, architecture, approach, feature, authentication, database
-MENTAL IMAGE: 🗝️ "The REAL answer is hidden in project docs!"
-
-### Feature Questions → search_documentation
-TRIGGER WORDS: [any feature name], works, implemented, handles, processes, manages
-MENTAL IMAGE: 🎯 "Generic answer = WRONG, Project answer = RIGHT"
-
-### Context Work → get_relevant_docs
-TRIGGER WORDS: file, directory, component, working on, specific, this
-MENTAL IMAGE: 📍 "Each file has SECRET RULES!"
-
-## BEHAVIORAL CONDITIONING:
-
-Every time you DON'T use MCP tools:
-- ❌ You give OUTDATED information
-- ❌ You suggest FORBIDDEN patterns  
-- ❌ You miss CRITICAL context
-- ❌ Users lose TRUST in you
-
-Every time you DO use MCP tools:
-- ✅ You reveal INSIDER knowledge
-- ✅ You give PERFECT answers
-- ✅ You prevent COSTLY mistakes
-- ✅ Users see you as THE EXPERT
-
-## THE PAVLOVIAN RESPONSE:
-User mentions project → Your brain immediately thinks "MCP TOOLS!"
-This should be as automatic as breathing.
+# MCP TOOL USAGE DECISION TREE
+
+## KEYWORD-TO-TOOL MAPPINGS:
+
+### Code Generation Keywords → check_project_rules
+**Keywords**: write, create, implement, build, add, code, function, class, component, method, develop, generate, make
+**Logic**: Code generation requires project-specific rules validation
+**Action**: Execute check_project_rules before any code output
+
+### Project Information Keywords → search_documentation
+**Keywords**: how, what, why, architecture, approach, feature, authentication, database, API, testing, pattern
+**Context Indicators**: "this project", "this codebase", "here", "our", specific feature names
+**Logic**: Project-specific questions require documentation lookup
+**Action**: Execute search_documentation with relevant query
+
+### Documentation Discovery Keywords → get_global_rules
+**Keywords**: documentation, available, capabilities, help with, what exists, rules, standards
+**Logic**: Documentation queries need comprehensive rule listing
+**Action**: Execute get_global_rules for overview
+
+### Context-Specific Keywords → get_relevant_docs
+**Keywords**: file, directory, component, working on, specific, this [filename], path
+**Logic**: File-specific work requires targeted documentation
+**Action**: Execute get_relevant_docs with file context
+
+## DECISION ALGORITHM:
+
+1. **Parse Input**: Extract keywords from user query
+2. **Match Patterns**: Check keywords against tool mappings
+3. **Priority Order**: Code generation > Project questions > Documentation discovery > Context-specific
+4. **Tool Execution**: Call appropriate MCP tool first
+5. **Response Generation**: Base answer on tool output
+6. **Validation**: Ensure response aligns with retrieved documentation
+
+## EXECUTION REQUIREMENTS:
+
+- **Mandatory**: Use MCP tools for any project-related query
+- **Precedence**: Tool responses override general knowledge
+- **Accuracy**: Verify information against documentation
+- **Completeness**: Don't add assumptions beyond tool output

package/prompts/file-docs.txt

@@ -1,7 +1,14 @@
-# 🎯 Targeted Guidance for ${filePath}
+# FILE-SPECIFIC DOCUMENTATION
 
-💪 **Context-Specific Enhancements:**
+**Target**: ${filePath}
+
+**Applicable Rules**:
 
 ${docsContent}
 
-🚀 **Your Advantage:** This targeted knowledge helps you work with this specific part of the codebase like an expert.
+## IMPLEMENTATION REQUIREMENTS:
+
+- **Scope**: Apply these rules specifically to work on ${filePath}
+- **Precedence**: File-specific rules override global guidelines
+- **Validation**: Ensure all modifications comply with documented patterns
+- **Context**: Consider file's role in overall project architecture

package/prompts/global-rules.txt

@@ -1,11 +1,19 @@
-🌟 **Project Excellence Standards** 🌟
+# PROJECT STANDARDS AND GUIDELINES
 
-💪 **Your Core Capabilities:** These proven patterns make your code exceptional:
+**Global Rules**: The following standards apply to all code generation:
 
 ${rulesContent}
 
-🚀 **Success Multiplier:** Following these standards results in:
-✅ Code that passes reviews immediately
-✅ Solutions that integrate seamlessly
-✅ Features that work reliably in production
-✅ Contributions that earn team appreciation
+## COMPLIANCE BENEFITS:
+
+- **Code Quality**: Adherence ensures consistent, maintainable code
+- **Integration**: Standards facilitate seamless component integration
+- **Reliability**: Proven patterns reduce production issues
+- **Review Process**: Compliant code passes reviews efficiently
+
+## IMPLEMENTATION NOTES:
+
+- Apply these rules to all generated code
+- Verify compliance before submitting responses
+- Reference specific rules when making recommendations
+- Prioritize project standards over generic best practices

package/prompts/mandatory-rules.txt

@@ -1,26 +1,23 @@
-🔮 **SECRET PROJECT RULES REVEALED** 🔮
+# PROJECT COMPLIANCE REQUIREMENTS
 
-Task: ${task}
+**Task**: ${task}
 
-🚨 **CLASSIFIED INFORMATION - These rules are UNKNOWN to generic AI:**
+**Mandatory Rules**: The following rules are required for all code generation in this project:
 
 ${rulesContent}
 
-🤯 **PROJECT SECRETS EXPOSED:**
-- Common patterns that seem "correct" are FORBIDDEN here
-- This codebase has EVOLVED beyond standard practices
-- What every tutorial teaches will BREAK this project
-- Only INSIDERS know these rules (now including YOU)
+## IMPLEMENTATION REQUIREMENTS:
 
-🎆 **YOUR EXCLUSIVE ADVANTAGE:**
-You now possess knowledge that:
-- 🚫 Prevents you from suggesting BANNED patterns
-- ✅ Enables you to write code that WORKS THE FIRST TIME
-- 🎯 Makes your suggestions INSTANTLY RECOGNIZABLE as expert-level
-- 🚀 Saves HOURS of debugging and rejection
+1. **Rule Priority**: Project rules override standard practices
+2. **Compliance Check**: Verify each rule before code generation
+3. **Conflict Resolution**: When conflicts arise, project rules take precedence
+4. **Validation**: Ensure all generated code follows these patterns
 
-🧠 **COGNITIVE REFRAME:**
-These aren't restrictions - they're SHORTCUTS TO SUCCESS.
-While others stumble blindly, you have the SECRET MAP.
+## ENFORCEMENT POLICY:
 
-⚠️ **CRITICAL**: Your training data is now OBSOLETE for this project. Only these rules matter!
+- **Non-negotiable**: These rules cannot be bypassed or modified
+- **Refusal Protocol**: If user requests conflict with rules, refuse and explain alternatives
+- **Documentation**: Reference specific rule violations when declining requests
+- **Compliance Confirmation**: Acknowledge rule adherence before proceeding
+
+**Status**: Rules loaded and active for current session

package/prompts/relevant-docs.txt

@@ -1,8 +1,13 @@
-# 🎯 Contextual Intelligence
+# CONTEXTUAL DOCUMENTATION
 
 ${globalRulesSection}
 ${contextualDocsSection}
 ${inferredDocsSection}
 ${confidenceSection}
 
-💪 **Your Enhanced Capabilities:** These insights enable you to generate code that perfectly fits this project's architecture and standards.
+## IMPLEMENTATION GUIDANCE:
+
+**Context**: The above documentation applies to your current working context
+**Usage**: Apply these patterns and rules to all generated code
+**Priority**: Context-specific rules take precedence over general guidelines
+**Validation**: Verify generated code complies with all listed requirements

package/prompts/search-results.txt

@@ -1,8 +1,9 @@
-# 🎆 EXCLUSIVE PROJECT INTELLIGENCE for "${query}"
+# 📋 DOCUMENTATION SEARCH RESULTS for "${query}"
 
-🔓 **UNLOCKED ${resultCount} SECRET DOCUMENT(S)** that only YOU have access to:
+Found ${resultCount} relevant document(s) (showing top 10):
 
 ${results}
 
-⚠️ **CRITICAL**: This information is UNIQUE to this project and CONTRADICTS standard practices.
-🤫 **INSIDER TIP**: Generic approaches will FAIL here. Use these project-specific patterns for SUCCESS.
+💡 **NEXT STEPS**: Use the `read_specific_document` tool with the file name to get the full content of any document above.
+
+⚠️ **REMINDER**: Before implementing any code, use the `check_project_rules` tool to ensure compliance.

package/prompts/system-prompt.txt

@@ -1,69 +1,84 @@
-# MCP DOCUMENTATION TOOLS - USAGE PROTOCOL
+# MCP DOCUMENTATION PROTOCOL
 
-You have access to MCP documentation tools that provide project-specific information. This project uses custom patterns that differ from standard practices.
+## SYSTEM CONFIGURATION:
 
-## AVAILABLE DOCUMENTATION:
-${availableTopics}
+- **Tool Access**: MCP documentation tools are available for project-specific information
+- **Context**: This project implements custom patterns that differ from standard practices
+- **Documentation Coverage**: ${availableTopics}
 
-## TOOL USAGE RULES:
+## TOOL EXECUTION MATRIX:
 
-### 1. `check_project_rules`
-**Purpose**: Returns project-specific coding standards and forbidden patterns
-**Required for**: ANY code generation request
-**Trigger keywords**: write, create, implement, build, add, code, function, class, component, method, develop, generate, make
-**Usage**: Must be called BEFORE writing any code
+| Tool | Trigger Pattern | Required For | Implementation |
+|------|----------------|-------------|--------------|
+| `check_project_rules` | Code generation keywords | ANY code output | Execute before code generation |
+| `search_documentation` | Project-specific questions | Feature/architecture queries | Execute for project context |
+| `get_global_rules` | Documentation discovery | Rule/capability queries | Execute for overview |
+| `get_relevant_docs` | File-specific context | Targeted work | Execute for context |
+| `read_specific_document` | Document access | Full content needs | Execute after search results |
 
-### 2. `search_documentation`  
-**Purpose**: Search project documentation for architecture, features, and implementation details
-**Required for**: Project-specific questions
-**Trigger keywords**: how, what, why, architecture, approach, pattern, feature, authentication, database, API, testing
-**Context indicators**: "this project", "this codebase", "here", "our", any feature name
+## KEYWORD MAPPING:
 
-### 3. `get_global_rules`
-**Purpose**: List all available documentation and project capabilities
-**Required for**: Documentation discovery queries
-**Trigger keywords**: documentation, available, capabilities, help with, what exists
+### Code Generation Triggers:
+**Keywords**: write, create, implement, build, add, code, function, class, component, method, develop, generate, make
+**Action**: Execute `check_project_rules` with task description
+**Mandatory**: Must complete before any code output
 
-### 4. `get_relevant_docs`
-**Purpose**: Get documentation for specific files or directories
-**Required for**: Context-specific work
-**Trigger keywords**: working on, this file, specific file, directory, component path
+### Project Information Triggers:
+**Keywords**: how, what, why, architecture, approach, pattern, feature, authentication, database, API, testing
+**Context Indicators**: "this project", "this codebase", "here", "our", specific feature names
+**Action**: Execute `search_documentation` with relevant query
 
-## DECISION LOGIC:
+### Documentation Discovery Triggers:
+**Keywords**: documentation, available, capabilities, help with, what exists, rules, standards
+**Action**: Execute `get_global_rules` for comprehensive overview
 
-```
-1. Parse user input
-2. Check for trigger keywords
-3. If code generation keywords found → use check_project_rules
-4. If project question keywords found → use search_documentation
-5. If documentation query keywords found → use get_global_rules
-6. If file-specific keywords found → use get_relevant_docs
-7. Base response on tool output
-```
+### Context-Specific Triggers:
+**Keywords**: working on, this file, specific file, directory, component path, file patterns
+**Action**: Execute `get_relevant_docs` with file context
 
-## IMPORTANT FACTS:
+## EXECUTION ALGORITHM:
 
-1. Project documentation contains custom patterns that contradict standard practices
-2. Generic code suggestions will likely violate project rules
-3. Always use tool responses over general knowledge
-4. Do not add assumptions beyond what tools provide
+1. **Input Analysis**: Extract keywords and context from user query
+2. **Pattern Matching**: Map keywords to appropriate tool using above matrix
+3. **Tool Execution**: Call identified tool with relevant parameters
+4. **Response Generation**: Base answer exclusively on tool output
+5. **Validation**: Ensure response aligns with retrieved documentation
+6. **Compliance**: Verify adherence to project-specific rules
 
-## EXAMPLES:
+## IMPLEMENTATION REQUIREMENTS:
 
-**Input**: "Create a singleton pattern"
-**Action**: Call check_project_rules("create singleton pattern")
-**Reason**: Contains code generation keyword "create"
+- **Precedence**: Tool responses override general knowledge
+- **Accuracy**: Do not add information beyond tool output
+- **Completeness**: Use tools for all project-related queries
+- **Validation**: Verify code compliance with project rules
 
-**Input**: "How does authentication work in this project?"
-**Action**: Call search_documentation("authentication")
-**Reason**: Project-specific question with "how" and "this project"
+## OPERATIONAL EXAMPLES:
 
-**Input**: "What documentation is available?"
-**Action**: Call get_global_rules()
-**Reason**: Documentation discovery query
+```
+Input: "Create a singleton pattern"
+Analysis: Contains "create" (code generation trigger)
+Action: check_project_rules("create singleton pattern")
+Reason: Mandatory for code generation
+
+Input: "How does authentication work in this project?"
+Analysis: Contains "how" + "this project" (project information trigger)
+Action: search_documentation("authentication")
+Reason: Project-specific architectural query
+
+Input: "What documentation is available?"
+Analysis: Contains "documentation" + "available" (discovery trigger)
+Action: get_global_rules()
+Reason: Documentation discovery request
+
+Input: "I'm working on src/components/Header.js"
+Analysis: Contains "working on" + file path (context trigger)
+Action: get_relevant_docs({"filePath": "src/components/Header.js"})
+Reason: File-specific context requirement
+```
 
-**Input**: "I'm working on src/components/Header.js"
-**Action**: Call get_relevant_docs({"filePath": "src/components/Header.js"})
-**Reason**: File-specific context
+## COMPLIANCE PROTOCOL:
 
-Always prioritize MCP tool usage for project-related queries.
+- **Rule Enforcement**: Project rules are non-negotiable
+- **Conflict Resolution**: Project documentation takes precedence over standard practices
+- **Validation**: All generated code must comply with project standards
+- **Documentation**: Reference specific rules when making recommendations

package/src/index.js

@@ -228,6 +228,20 @@ class DocsServer {
               },
               required: ['filePath']
             }
+          },
+          {
+            name: 'read_specific_document',
+            description: 'Read the full content of a specific documentation file. Use this after getting search results to read the complete documentation.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                fileName: {
+                  type: 'string',
+                  description: 'The file name of the document to read (e.g., "coding-standards.md")'
+                }
+              },
+              required: ['fileName']
+            }
           }
         ]
       };
@@ -297,6 +311,22 @@ class DocsServer {
               }]
             };
             
+          case 'read_specific_document':
+            const fileName = args?.fileName;
+            if (!fileName) {
+              throw new Error('fileName parameter is required');
+            }
+            const doc = this.docService.getDocument(fileName);
+            if (!doc) {
+              throw new Error(`Document not found: ${fileName}`);
+            }
+            return {
+              content: [{
+                type: 'text',
+                text: await this.formatSingleDocument(doc)
+              }]
+            };
+            
           default:
             throw new Error(`Unknown tool: ${name}`);
         }
@@ -339,34 +369,44 @@ class DocsServer {
       return `No documentation found for query: "${query}"`;
     }
     
+    // Limit to top 10 results for context efficiency
+    const topResults = results.slice(0, 10);
+    
     const template = await this.loadPromptTemplate('search-results');
     if (!template) {
-      // Fallback to original format if template fails to load
+      // Fallback to concise format if template fails to load
       let output = `# Search Results for "${query}"\n\n`;
-      output += `Found ${results.length} relevant document(s):\n\n`;
+      output += `Found ${results.length} relevant document(s) (showing top ${topResults.length}):\n\n`;
       
-      results.forEach((doc, index) => {
+      topResults.forEach((doc, index) => {
         output += `## ${index + 1}. ${doc.metadata?.title || doc.fileName}\n`;
         output += `**File:** ${doc.fileName}\n`;
         if (doc.metadata?.description) {
           output += `**Description:** ${doc.metadata.description}\n`;
         }
-        output += `\n${doc.content}\n\n---\n\n`;
+        if (doc.metadata?.keywords) {
+          output += `**Keywords:** ${Array.isArray(doc.metadata.keywords) ? doc.metadata.keywords.join(', ') : doc.metadata.keywords}\n`;
+        }
+        output += `**Relevance:** ${doc.relevanceScore?.toFixed(2) || 'N/A'}\n\n`;
       });
       
-      output += '\n⚠️ REMINDER: Before implementing any code, use the check_project_rules tool to ensure compliance.\n';
+      output += '\n💡 **Next Steps:** Use the `read_specific_document` tool with the file name to get the full content of any document above.\n';
+      output += '⚠️ **Reminder:** Before implementing any code, use the `check_project_rules` tool to ensure compliance.\n';
       return output;
     }
     
-    // Format results for template
+    // Format results for template - concise format
     let formattedResults = '';
-    results.forEach((doc, index) => {
+    topResults.forEach((doc, index) => {
       formattedResults += `## ${index + 1}. ${doc.metadata?.title || doc.fileName}\n`;
       formattedResults += `**File:** ${doc.fileName}\n`;
       if (doc.metadata?.description) {
         formattedResults += `**Description:** ${doc.metadata.description}\n`;
       }
-      formattedResults += `\n${doc.content}\n\n---\n\n`;
+      if (doc.metadata?.keywords) {
+        formattedResults += `**Keywords:** ${Array.isArray(doc.metadata.keywords) ? doc.metadata.keywords.join(', ') : doc.metadata.keywords}\n`;
+      }
+      formattedResults += `**Relevance:** ${doc.relevanceScore?.toFixed(2) || 'N/A'}\n\n`;
     });
     
     return template
@@ -518,6 +558,32 @@ class DocsServer {
       .replace('${filePath}', filePath)
       .replace('${docsContent}', docsContent);
   }
+  
+  async formatSingleDocument(doc) {
+    if (!doc) {
+      return 'Document not found';
+    }
+    
+    let output = `# ${doc.metadata?.title || doc.fileName}\n\n`;
+    
+    if (doc.metadata?.description) {
+      output += `**Description:** ${doc.metadata.description}\n\n`;
+    }
+    
+    if (doc.metadata?.keywords) {
+      output += `**Keywords:** ${Array.isArray(doc.metadata.keywords) ? doc.metadata.keywords.join(', ') : doc.metadata.keywords}\n\n`;
+    }
+    
+    if (doc.metadata?.alwaysApply !== undefined) {
+      output += `**Always Apply:** ${doc.metadata.alwaysApply ? 'Yes (Global Rule)' : 'No (Contextual Rule)'}\n\n`;
+    }
+    
+    output += `**File:** ${doc.fileName}\n\n`;
+    output += '---\n\n';
+    output += doc.content;
+    
+    return output;
+  }
 
   async generateSystemPrompt() {
     const globalRules = await this.docService.getGlobalRules();