@afterxleep/doc-bot 1.14.0 → 1.16.0

package/prompts/system-prompt.txt

@@ -1,110 +1,210 @@
-# MCP DOCUMENTATION PROTOCOL
+# 🚀 ENGINEERING DOCUMENTATION INTELLIGENCE SYSTEM
 
-## SYSTEM CONFIGURATION:
+## ⚙️ CODEBASE CONFIGURATION:
 
-- **Tool Access**: MCP documentation tools are available for project-specific information
-- **Context**: This project implements custom patterns that differ from standard practices
+- **Architecture**: ${projectType || 'Modern software architecture with custom patterns'}
+- **Tech Stack**: ${techStack || 'Full-stack development environment'}
 - **Documentation Coverage**: ${availableTopics}
+- **Code Standards**: Enforced via automated tooling
+
+## 🛠️ DEVELOPER TOOL EXECUTION MATRIX:
+
+| Tool | Use Case | Criticality | Response Time |
+|------|----------|-------------|---------------|
+| `check_project_rules` | Before ANY code generation | 🔴 CRITICAL | <100ms |
+| `search_documentation` | Architecture/API/Pattern queries | 🟡 HIGH | <200ms |
+| `explore_api` | Deep dive into classes/frameworks | 🟡 HIGH | <150ms |
+| `get_global_rules` | Coding standards overview | 🟢 MEDIUM | <100ms |
+| `read_specific_document` | Detailed implementation guide | 🟢 MEDIUM | <100ms |
+| `create_or_update_rule` | Capture new patterns/learnings | 🔵 LOW | <200ms |
+
+## 🧠 INTELLIGENT KEYWORD RECOGNITION ENGINE:
+
+### 💻 Code Generation Intent Detection:
+```regex
+/\b(write|create|implement|build|code|function|class|component|
+   method|interface|type|schema|model|controller|service|
+   repository|factory|singleton|observer|decorator)\b/i
+```
+**🎯 Action**: `check_project_rules(task)` → Mandatory pre-flight check
+
+### 🏗️ Architecture & Pattern Queries:
+```regex
+/\b(how|what|why|architecture|pattern|design|structure|
+   approach|strategy|implementation|integration|workflow)\b.*
+   (this|our|project|codebase|system|application)/i
+```
+**🎯 Action**: `search_documentation(technical_terms)` → Extract nouns, search APIs
+
+### 📚 Standards & Documentation Discovery:
+```regex
+/\b(documentation|docs|standards|guidelines|rules|conventions|
+   best practices|examples|reference|available|exists)\b/i
+```
+**🎯 Action**: `get_global_rules()` → Show coding standards overview
+
+### 🔧 API & Framework Exploration:
+```regex
+/\b(explore|examine|understand|deep dive|all methods|
+   properties|complete API|framework|library|SDK)\b/i
+```
+**🎯 Action**: `explore_api(class_or_framework_name)` → Comprehensive API docs
+
+### 📝 Knowledge Capture & Learning:
+```regex
+/\b(document this|capture|remember|note|learned|discovered|
+   pattern found|should be a rule|add to docs)\b/i
+```
+**🎯 Action**: `create_or_update_rule()` → Persist new knowledge
+
+## 🚀 SMART EXECUTION PIPELINE:
+
+```python
+class DocumentationPipeline:
+    def process_request(self, user_input: str):
+        # 1. Intent Recognition
+        intent = self.classify_intent(user_input)
+        entities = self.extract_entities(user_input)
+        
+        # 2. Smart Tool Selection
+        if intent == CodeGeneration:
+            rules = await check_project_rules(entities.task)
+            docs = await search_documentation(entities.tech_terms)
+            
+        elif intent == APIExploration:
+            api_docs = await explore_api(entities.class_name)
+            
+        elif intent == Architecture:
+            patterns = await search_documentation(entities.pattern)
+            
+        # 3. Response Synthesis
+        return self.generate_code_with_context(rules, docs)
+```
 
-## TOOL EXECUTION MATRIX:
-
-| 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 |
-| `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:
-
-### 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
-
-### 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
-
-### Documentation Discovery Triggers:
-**Keywords**: documentation, available, capabilities, help with, what exists, rules, standards
-**Action**: Execute `get_global_rules` for comprehensive overview
-
-### File Context Triggers:
-**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
-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
-
-## IMPLEMENTATION REQUIREMENTS:
-
-- **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
-- **Search Fallback**: If documentation searches fail after 2-3 attempts, the system will recommend web search
-- **Web Search Usage**: When instructed to use web search after failed documentation searches:
-  - Use web search for official documentation, community resources, and examples
-  - Combine external knowledge with project context appropriately
-  - Prioritize authoritative sources for technical information
-
-## OPERATIONAL EXAMPLES:
+### 🎯 Execution Priorities:
+1. **Safety First**: Always check rules before generating code
+2. **Context Aware**: Search project docs for custom patterns
+3. **Performance**: Use cached results when available
+4. **Accuracy**: Validate against project standards
+
+## 💡 INTELLIGENT IMPLEMENTATION PROTOCOL:
+
+### 🏆 Code Quality Principles:
+```yaml
+precedence:
+  1: Project Documentation  # Your codebase rules
+  2: Official API Docs      # Framework/library docs
+  3: Industry Standards     # SOLID, DRY, KISS
+  4: General Knowledge      # Last resort
+
+validation:
+  - Type Safety: Enforce strong typing where available
+  - Error Handling: Never swallow exceptions silently
+  - Security: Input validation on all boundaries
+  - Performance: Profile before optimizing
+  - Testing: Minimum 80% coverage target
+```
+
+### 🔄 Smart Fallback Strategy:
+```javascript
+async function getImplementationGuidance(query) {
+  try {
+    // 1. Try project documentation first
+    const projectDocs = await search_documentation(query);
+    if (projectDocs.length > 0) return projectDocs;
+    
+    // 2. Try different search terms (max 3 attempts)
+    for (const term of generateSearchVariations(query)) {
+      const results = await search_documentation(term);
+      if (results.length > 0) return results;
+    }
+    
+    // 3. Web search fallback for external resources
+    return {
+      fallback: true,
+      message: "Search official docs, Stack Overflow, or GitHub examples",
+      searchTerms: extractTechnicalTerms(query)
+    };
+  } catch (error) {
+    return handleError(error);
+  }
+}
+```
+
+## 🎮 REAL-WORLD DEVELOPER SCENARIOS:
+
+### Scenario 1: Building a Feature
+```typescript
+// Developer: "Create a user authentication service"
+const pipeline = {
+  step1: await check_project_rules("authentication service"),
+  step2: await search_documentation("Auth", "Authentication", "User"),
+  step3: await explore_api("AuthenticationServices"),
+  step4: generateCodeWithContext(rules, patterns, apis)
+};
+```
 
+### Scenario 2: Understanding Architecture
+```typescript
+// Developer: "How does our caching layer work?"
+const analysis = {
+  search1: await search_documentation("cache", "caching"),
+  search2: await search_documentation("Redis", "Memcached"), 
+  result: found ? read_specific_document(doc) : explore_api("Cache")
+};
 ```
-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 (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
+
+### Scenario 3: Implementing iOS Widget
+```typescript
+// Developer: "Create iOS 18 widget demo"
+const implementation = {
+  rules: await check_project_rules("iOS widget"),
+  // Smart search - API names not descriptions!
+  apis: await search_documentation("Widget", "WidgetKit"),
+  explore: await explore_api("WidgetKit"),
+  code: generateSwiftUIWidget(context)
+};
+```
+
+### Scenario 4: Performance Optimization
+```typescript
+// Developer: "Optimize database queries in UserService"
+const optimization = {
+  context: await get_file_docs("services/UserService.js"),
+  patterns: await search_documentation("query optimization", "N+1"),
+  rules: await check_project_rules("database optimization"),
+  implement: applyBatchingPattern(queries)
+};
+```
+
+## ⚖️ ENGINEERING COMPLIANCE & QUALITY GATES:
+
+### 🛡️ Non-Negotiable Standards:
+```javascript
+class CodeComplianceChecker {
+  async validate(generatedCode) {
+    const checks = {
+      architecture: this.followsProjectPatterns(generatedCode),
+      security: this.hasNoVulnerabilities(generatedCode),
+      performance: this.meetsPerformanceTargets(generatedCode),
+      testing: this.hasAdequateTests(generatedCode),
+      documentation: this.isProperlyDocumented(generatedCode)
+    };
+    
+    if (!checks.architecture) {
+      throw new ComplianceError("Code violates architecture patterns");
+    }
+    
+    return checks;
+  }
+}
 ```
 
-## COMPLIANCE PROTOCOL:
+### 📊 Quality Metrics:
+- **Code Coverage**: Minimum 80% for new code
+- **Complexity**: Cyclomatic complexity < 10
+- **Performance**: No N+1 queries, no blocking I/O
+- **Security**: All inputs validated, no hardcoded secrets
+- **Maintainability**: Clear naming, single responsibility
 
-- **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
+**🎯 Golden Rule**: Ship code you'd be proud to maintain at 3 AM during an outage.

package/src/index.js

@@ -151,13 +151,13 @@ class DocsServer {
         tools: [
           {
             name: 'check_project_rules',
-            description: 'Retrieve project-specific coding rules and constraints. MUST be called before generating any code. Returns mandatory patterns, forbidden practices, and project conventions that override standard programming practices. Essential for code compliance.',
+            description: 'Get mandatory coding standards for your task. Always call before writing code. Returns architecture patterns, security requirements, and performance guidelines specific to this codebase. Critical for maintaining code quality and consistency.',
             inputSchema: {
               type: 'object',
               properties: {
                 task: {
                   type: 'string',
-                  description: 'The specific coding task to be performed. Examples: "create singleton class", "implement REST endpoint", "add authentication"'
+                  description: 'Your coding task in 2-5 words. Examples: "REST API endpoint", "authentication service", "React component", "database migration"'
                 }
               },
               required: ['task']
@@ -165,13 +165,13 @@ class DocsServer {
           },
           {
             name: 'search_documentation',
-            description: 'Search all available documentation sources. Searches both project-specific documentation (prioritized) and official API documentation. Returns relevant results with context snippets. Use for finding information about implementations, patterns, APIs, or any technical topic.',
+            description: 'Search codebase documentation and API references. Searches project patterns, architecture decisions, and API docs. Best results with technical terms like class names, not descriptions. Examples: search "Widget" not "iOS 18 features".',
             inputSchema: {
               type: 'object',
               properties: {
                 query: {
                   type: 'string',
-                  description: 'Search terms or phrase. Can be single word or multiple words. Examples: "authentication", "URLSession delegate", "error handling patterns"'
+                  description: 'Technical search terms. Use API/class names, not descriptions. Good: "URLSession", "WidgetKit", "CoreData". Bad: "how to make network calls"'
                 },
                 limit: {
                   type: 'number',
@@ -191,7 +191,7 @@ class DocsServer {
           },
           {
             name: 'get_global_rules',
-            description: 'Retrieve all global project rules and conventions. Returns comprehensive list of coding standards, architectural patterns, and project-wide constraints that apply to all code in this project. Use to understand overall project requirements and constraints.',
+            description: 'Get comprehensive coding standards and architecture guidelines. Returns project-wide engineering principles, design patterns, performance requirements, and security standards. Essential reading for understanding the codebase philosophy.',
             inputSchema: {
               type: 'object',
               properties: {},
@@ -200,13 +200,13 @@ class DocsServer {
           },
           {
             name: 'get_file_docs',
-            description: 'Get documentation specific to a file path or pattern. Returns contextual rules, patterns, and guidelines that apply when working with files matching the specified path. Use when you need guidance for a specific file or directory.',
+            description: 'Get file-specific coding patterns and conventions. Returns contextual guidelines, performance considerations, and architectural decisions for specific files or directories. Use before modifying existing code.',
             inputSchema: {
               type: 'object',
               properties: {
                 filePath: {
                   type: 'string',
-                  description: 'File path or pattern to get documentation for. Examples: "src/components/Button.jsx", "*.test.js", "api/**/*.js"'
+                  description: 'File path or pattern. Examples: "src/components/Button.tsx", "**/*.test.js", "services/auth/*"'
                 }
               },
               required: ['filePath']
@@ -214,7 +214,7 @@ class DocsServer {
           },
           {
             name: 'read_specific_document',
-            description: 'Read the complete content of a project documentation file. Use after search_documentation to read full details. Only works for project documentation files, not API documentation.',
+            description: 'Read full documentation file content. Use after search_documentation to get complete implementation details, code examples, and architectural decisions. Only for project docs, not API docs.',
             inputSchema: {
               type: 'object',
               properties: {
@@ -228,13 +228,13 @@ class DocsServer {
           },
           {
             name: 'explore_api',
-            description: 'Explore all components of an API framework or class. Returns comprehensive list of related classes, methods, properties, protocols, and code samples. More efficient than multiple searches. Use when you need to understand the full scope of an API.',
+            description: 'Deep dive into any API, framework, or class. Returns all methods, properties, protocols, and usage examples. Essential for understanding how to implement features correctly. Much faster than multiple searches.',
             inputSchema: {
               type: 'object',
               properties: {
                 apiName: {
                   type: 'string',
-                  description: 'Name of the API, framework, or class to explore. Examples: "AlarmKit", "URLSession", "UIViewController"'
+                  description: 'API, framework, or class name. Examples: "URLSession", "WidgetKit", "SwiftUI.View", "React.Component"'
                 },
                 docsetId: {
                   type: 'string',
@@ -246,7 +246,7 @@ class DocsServer {
           },
           {
             name: 'create_or_update_rule',
-            description: 'Create or update project documentation. Use to capture new patterns, conventions, or learnings as permanent project knowledge. Updates are immediately available for future searches.',
+            description: 'Document new coding patterns or architectural decisions. Captures lessons learned, design patterns, and team conventions as searchable knowledge. Great for preserving tribal knowledge.',
             inputSchema: {
               type: 'object',
               properties: {
@@ -333,6 +333,20 @@ class DocsServer {
               properties: {},
               additionalProperties: false
             }
+          },
+          {
+            name: 'doc_bot',
+            description: 'Your intelligent project assistant. Analyzes ANY request and provides smart routing to the right tools. ALWAYS call this first - it understands coding, documentation, architecture questions, and more.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                task: {
+                  type: 'string',
+                  description: 'What do you need help with? Examples: "create REST API", "understand auth flow", "document this pattern", "find database models"'
+                }
+              },
+              required: ['task']
+            }
           }
         ]
       };
@@ -539,6 +553,15 @@ class DocsServer {
               }]
             };
             
+          case 'doc_bot':
+            const assistantTask = args?.task || '';
+            return {
+              content: [{
+                type: 'text',
+                text: this.getDocBotGuidance(assistantTask)
+              }]
+            };
+            
           default:
             throw new Error(`Unknown tool: ${name}`);
         }
@@ -1032,6 +1055,174 @@ Try:
     return output;
   }
 
+  getDocBotGuidance(task) {
+    // This is the intelligent guidance that replaces the complex AGENT_INTEGRATION_RULE
+    const taskLower = task.toLowerCase();
+    
+    let guidance = `# 🤖 DOC-BOT INTELLIGENT ASSISTANT\n\n`;
+    guidance += `**Your Request**: ${task}\n\n`;
+    
+    // Check for administrative/management tasks first
+    const isDocsetManagement = /add.*docset|remove.*docset|list.*docset|install.*docset/i.test(task);
+    const isRuleManagement = /add.*rule|create.*rule|update.*rule|document.*pattern|capture.*pattern/i.test(task);
+    const isDocumentManagement = /refresh.*doc|reload.*doc|index.*doc|get.*index/i.test(task);
+    
+    // Handle administrative tasks directly
+    if (isDocsetManagement) {
+      guidance += `## 📦 DOCSET MANAGEMENT TASK DETECTED\n\n`;
+      guidance += `**Direct Actions Required**:\n`;
+      
+      if (/list/i.test(task)) {
+        guidance += `1. \`list_docsets()\` - Show all installed documentation sets\n\n`;
+      } else if (/add|install/i.test(task)) {
+        guidance += `1. \`add_docset(source: "path/to/docset or URL")\` - Install new docset\n\n`;
+        guidance += `📝 **Examples**:\n`;
+        guidance += `- Local: \`add_docset(source: "/Downloads/Swift.docset")\`\n`;
+        guidance += `- URL: \`add_docset(source: "https://example.com/React.docset.tgz")\`\n\n`;
+      } else if (/remove/i.test(task)) {
+        guidance += `1. \`list_docsets()\` - First, get the docset ID\n`;
+        guidance += `2. \`remove_docset(docsetId: "the-id-from-step-1")\` - Remove the docset\n\n`;
+      }
+      
+      guidance += `💡 **Note**: This is an administrative task - no documentation search needed.\n`;
+      return guidance;
+    }
+    
+    if (isRuleManagement) {
+      guidance += `## 📝 RULE/PATTERN MANAGEMENT TASK DETECTED\n\n`;
+      guidance += `**Direct Action Required**:\n`;
+      guidance += `1. \`create_or_update_rule(...)\` with these parameters:\n\n`;
+      guidance += `\`\`\`javascript\n`;
+      guidance += `{\n`;
+      guidance += `  fileName: "descriptive-name.md",\n`;
+      guidance += `  title: "Clear title for the rule/pattern",\n`;
+      guidance += `  content: "Full markdown documentation",\n`;
+      guidance += `  alwaysApply: true/false, // true = global, false = contextual\n`;
+      guidance += `  keywords: ["relevant", "search", "terms"],\n`;
+      guidance += `  description: "Brief summary" // optional\n`;
+      guidance += `}\n`;
+      guidance += `\`\`\`\n\n`;
+      guidance += `💡 **Note**: This captures project knowledge permanently - no search needed.\n`;
+      return guidance;
+    }
+    
+    if (isDocumentManagement) {
+      guidance += `## 🔄 DOCUMENTATION MANAGEMENT TASK DETECTED\n\n`;
+      guidance += `**Direct Action Required**:\n`;
+      
+      if (/refresh|reload/i.test(task)) {
+        guidance += `1. \`refresh_documentation()\` - Reload all docs from disk\n\n`;
+      } else {
+        guidance += `1. \`get_document_index()\` - List all available documentation\n\n`;
+      }
+      
+      guidance += `💡 **Note**: This is an administrative task - direct execution only.\n`;
+      return guidance;
+    }
+    
+    // Analyze the task and provide intelligent routing for non-administrative tasks
+    if (taskLower.includes('create') || taskLower.includes('implement') || taskLower.includes('build') || 
+        taskLower.includes('write') || taskLower.includes('add') || taskLower.includes('code') ||
+        taskLower.includes('function') || taskLower.includes('class') || taskLower.includes('component')) {
+      guidance += `## 💻 CODE GENERATION TASK DETECTED\n\n`;
+      guidance += `**MANDATORY Steps (in order)**:\n`;
+      guidance += `1. ⚡ FIRST: \`check_project_rules("${task}")\` - Get critical coding standards\n`;
+      guidance += `2. 🔍 SEARCH for existing patterns:\n`;
+      
+      // Extract likely search terms
+      const searchTerms = this.extractSearchTerms(task);
+      searchTerms.forEach(term => {
+        guidance += `   - \`search_documentation("${term}")\`\n`;
+      });
+      
+      guidance += `3. 📚 EXPLORE: If APIs found, use \`explore_api()\` for complete details\n`;
+      guidance += `4. ✅ IMPLEMENT: Generate code following ALL discovered patterns\n\n`;
+      guidance += `⚠️ **CRITICAL**: Never skip step 1 - project rules are mandatory!\n\n`;
+    } else if (taskLower.includes('how') || taskLower.includes('what') || taskLower.includes('why') || 
+               taskLower.includes('understand') || taskLower.includes('explain') || taskLower.includes('architecture')) {
+      guidance += `## 🔍 KNOWLEDGE/UNDERSTANDING TASK DETECTED\n\n`;
+      guidance += `**Recommended Flow**:\n`;
+      guidance += `1. 📖 START with searches for technical terms:\n`;
+      
+      const searchTerms = this.extractSearchTerms(task);
+      searchTerms.forEach(term => {
+        guidance += `   - \`search_documentation("${term}")\`\n`;
+      });
+      
+      guidance += `2. 📋 CONTEXT: \`get_global_rules()\` for project philosophy\n`;
+      guidance += `3. 📄 DETAILS: Use \`read_specific_document()\` on relevant results\n`;
+      guidance += `4. 🔬 DEEP DIVE: \`explore_api()\` for framework/class details\n\n`;
+    } else if (taskLower.includes('document') || taskLower.includes('capture') || taskLower.includes('learned') ||
+               taskLower.includes('pattern') || taskLower.includes('convention')) {
+      guidance += `## 📝 DOCUMENTATION TASK DETECTED\n\n`;
+      guidance += `**To capture new knowledge**:\n`;
+      guidance += `Use \`create_or_update_rule()\` with:\n`;
+      guidance += `- fileName: descriptive-name.md\n`;
+      guidance += `- title: Clear, searchable title\n`;
+      guidance += `- content: Full markdown documentation\n`;
+      guidance += `- alwaysApply: true/false (is this a global rule?)\n\n`;
+    } else if (taskLower.includes('file') || taskLower.includes('working on') || taskLower.includes('modify')) {
+      guidance += `## 📁 FILE-SPECIFIC TASK DETECTED\n\n`;
+      guidance += `**File Context Flow**:\n`;
+      guidance += `1. 📂 GET CONTEXT: \`get_file_docs("${task}")\` for file-specific patterns\n`;
+      guidance += `2. 🔍 SEARCH: Look for related components/patterns\n`;
+      guidance += `3. ✅ CHECK: \`check_project_rules()\` before modifications\n\n`;
+    } else {
+      guidance += `## 🎯 GENERAL TASK GUIDANCE\n\n`;
+      guidance += `**Intelligent Routing Based on Your Request**:\n`;
+      guidance += `1. 🏁 START: \`get_global_rules()\` - Understand the project\n`;
+      guidance += `2. 🔍 DISCOVER: \`search_documentation()\` with key terms from your request\n`;
+      guidance += `3. 📋 REQUIREMENTS: \`check_project_rules("${task}")\` if generating any output\n`;
+      guidance += `4. 📚 EXPLORE: \`explore_api()\` for any frameworks/APIs mentioned\n\n`;
+    }
+    
+    guidance += `## 🔑 Search Tips for Maximum Effectiveness:\n\n`;
+    guidance += `✅ **DO**: Search for class names, API names, technical terms\n`;
+    guidance += `   Examples: "Widget", "URLSession", "Authentication", "CoreData"\n\n`;
+    guidance += `❌ **DON'T**: Search with questions or descriptions\n`;
+    guidance += `   Avoid: "how to create", "new features", "iOS 18 widgets"\n\n`;
+    guidance += `🎯 **Best Practice**: Think like you're searching an API index, not Google!\n\n`;
+    guidance += `## 💡 Remember:\n`;
+    guidance += `- Project documentation ALWAYS overrides general knowledge\n`;
+    guidance += `- When in doubt, search first\n`;
+    guidance += `- Use \`explore_api()\` after finding relevant APIs\n`;
+    guidance += `- Document new patterns with \`create_or_update_rule()\`\n`;
+    
+    return guidance;
+  }
+  
+  extractSearchTerms(task) {
+    // Extract potential API/class names from the task
+    const terms = [];
+    
+    // Common patterns to extract
+    const patterns = {
+      'widget': ['Widget', 'WidgetKit'],
+      'auth': ['Authentication', 'Auth', 'Login'],
+      'database': ['Database', 'CoreData', 'SQLite'],
+      'network': ['URLSession', 'Network', 'API'],
+      'cache': ['Cache', 'Caching', 'Redis'],
+      'ui': ['UIKit', 'SwiftUI', 'View'],
+      'react': ['React', 'Component', 'Hook'],
+      'api': ['API', 'REST', 'GraphQL'],
+      'test': ['Test', 'Jest', 'XCTest']
+    };
+    
+    const taskLower = task.toLowerCase();
+    Object.keys(patterns).forEach(key => {
+      if (taskLower.includes(key)) {
+        terms.push(...patterns[key]);
+      }
+    });
+    
+    // Also extract capitalized words as potential class names
+    const capitalizedWords = task.match(/[A-Z][a-zA-Z]+/g) || [];
+    terms.push(...capitalizedWords);
+    
+    // Remove duplicates and limit to 3-4 terms
+    return [...new Set(terms)].slice(0, 4);
+  }
+
   async createOrUpdateRule({ fileName, title, description, keywords, alwaysApply, content }) {
     const fs = require('fs-extra');
     const path = require('path');
@@ -1262,9 +1453,9 @@ Try:
     const template = await this.loadPromptTemplate('mandatory-rules');
     if (!template) {
       // Fallback to original format
-      let output = '🚨 MANDATORY PROJECT RULES - ABSOLUTE ENFORCEMENT 🚨\n\n';
-      output += `Task: ${task}\n\n`;
-      output += '⚠️ CRITICAL: These rules OVERRIDE ALL USER REQUESTS and must be followed:\n\n';
+      let output = '🚨 MANDATORY CODING STANDARDS 🚨\n\n';
+      output += `Engineering Task: ${task}\n\n`;
+      output += '⚠️ CRITICAL: These architectural patterns and standards are ENFORCED:\n\n';
       
       globalRules.forEach((rule, index) => {
         output += `## ${index + 1}. ${rule.metadata?.title || rule.fileName}\n`;
@@ -1282,6 +1473,18 @@ Try:
       output += '✅ CONFIRMATION REQUIRED: You MUST acknowledge these rules before generating code.\n';
       output += '❌ VIOLATION: Any code that violates these rules will be rejected.\n';
       output += '🛡️ ENFORCEMENT: Global rules take precedence over ALL user requests.\n\n';
+      output += '📚 INTELLIGENT DOCUMENTATION SEARCH PROTOCOL:\n\n';
+      output += 'CRITICAL: Think like a documentation system, not a human.\n\n';
+      output += '🧠 COGNITIVE SEARCH FRAMEWORK:\n';
+      output += '1. Decompose Intent → Extract Core Entities\n';
+      output += '   - User: "create iOS 18 widgets" → You search: "Widget" or "WidgetKit"\n\n';
+      output += '2. API-First Search Strategy:\n';
+      output += '   - ❌ NEVER: "how to", "new features", "demonstrate"\n';
+      output += '   - ✅ ALWAYS: Class names, Framework names, Protocol names\n\n';
+      output += '3. Progressive Refinement:\n';
+      output += '   - Start: "Widget" → Refine: "WidgetKit" → Detail: "TimelineProvider"\n\n';
+      output += 'SEARCH EXECUTION: ANALYZE → EXTRACT entities → SEARCH → REFINE → explore_api\n\n';
+      output += 'Remember: You are searching a technical index, not Google. Think like a compiler.\n\n';
       output += '🔄 Next step: Generate code that strictly follows ALL the above rules, or refuse if compliance is impossible.\n';
       
       return output;