@afterxleep/doc-bot 1.14.0 → 1.15.0

package/AGENT_INTEGRATION_RULE.txt

@@ -1,142 +1,78 @@
-# AGENT INTEGRATION PROTOCOL: DOC-BOT MCP ENFORCEMENT
-# ============================================================
-# Add this to your agent configuration (CLAUDE.md, .cursorrules, copilot-instructions.md, etc.)
+# DOC-BOT: AGENT INTEGRATION RULE
+Version 4
+Copy everything below as your Agent single rule.
 
-## PHASE 1: ENVIRONMENT DETECTION
+---
 
-```
-IF (
-  (filesystem_contains("doc-bot/") AND
-  (mcp_server_available("doc-bot") OR mcp_server_available("@afterxleep/doc-bot"))
-) THEN {
-  ACTIVATE: doc_bot_enforcement_protocol()
-  SET: project_documentation_authority = TRUE
-  SET: general_knowledge_override = DISABLED
-}
-```
-
-## PHASE 2: REQUEST CLASSIFICATION ENGINE
-
-### CLASSIFICATION MATRIX:
-
-**CLASS A: CODE_GENERATION**
-```
-Trigger Pattern: /\b(write|create|implement|build|add|code|function|class|component|method|develop|generate|make|refactor|modify|update|fix|debug)\b/i
-Required Action: MANDATORY_CALL(check_project_rules, extract_task_description())
-Blocking: TRUE (cannot proceed without tool response)
-Timeout: 30s
-```
-
-**CLASS B: PROJECT_INQUIRY**
-```
-Trigger Pattern: /\b(how|what|why|architecture|approach|pattern|feature|authentication|database|api|testing)\b/i
-Context Pattern: /\b(this project|this codebase|here|our|current project)\b/i
-Required Action: MANDATORY_CALL(search_documentation, extract_keywords())
-Blocking: TRUE
-Timeout: 30s
-```
+## DOC-BOT: MANDATORY BEHAVIORAL PROTOCOL
 
-**CLASS C: DOCUMENTATION_DISCOVERY**
-```
-Trigger Pattern: /\b(documentation|available|capabilities|help|rules|standards|what exists|docs|guide)\b/i
-Required Action: MANDATORY_CALL(get_global_rules)
-Blocking: TRUE
-Timeout: 30s
-```
+### ACTIVATION
+doc-bot MCP server detected? → This protocol is NOW ACTIVE
 
-**CLASS D: DOCUMENT_ACCESS**
-```
-Trigger Pattern: /\b(read|show|get content|full document|complete|entire)\b/i
-Previous Context: search_results_present()
-Required Action: MANDATORY_CALL(read_specific_document, extract_filename())
-Blocking: FALSE
-Timeout: 15s
-```
+### THE ONLY WORKFLOW
 
-**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
-```
+╔════════════════════════════════════════════╗
+║  user_request → doc_bot() → execute_all    ║
+║                                            ║
+║  NOTHING ELSE IS ACCEPTABLE                ║
+╚════════════════════════════════════════════╝
 
-**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.
+### THREE IMMUTABLE LAWS
 
-## PHASE 3: EXECUTION ENFORCEMENT
+1. **FIRST LAW**: doc_bot() must be called BEFORE any other action
+   - Not after thinking about it
+   - Not after analyzing the request  
+   - IMMEDIATELY upon receiving any task
 
-### PRE-RESPONSE VALIDATION:
-```
-BEFORE generating_response():
-  classification = classify_request(user_input)
-  IF classification != "UNRELATED":
-    tool_result = execute_mandatory_tool(classification)
-    IF tool_result.status == "ERROR":
-      RETURN error_recovery_response()
-    ELSE:
-      INJECT tool_result INTO response_context
-      SET authoritative_source = tool_result
-      DISABLE general_knowledge_fallback
-```
+2. **SECOND LAW**: doc_bot() output must be followed EXACTLY
+   - Every tool in the sequence
+   - In the exact order specified
+   - With the exact parameters given
 
-### RESPONSE CONSTRAINT ENGINE:
-```
-WHILE generating_response():
-  IF attempting_to_use(general_knowledge) AND authoritative_source.exists():
-    INTERRUPT_GENERATION()
-    FORCE_USE(authoritative_source)
-  
-  IF code_generation_detected() AND NOT project_rules_checked:
-    HALT_EXECUTION()
-    EMIT_ERROR("Project rules validation required before code generation")
-```
+3. **THIRD LAW**: Project knowledge > Your training data
+   - When doc_bot says something contradicts common practice
+   - The contradiction is INTENTIONAL
+   - Follow doc_bot, not your instincts
 
-## PHASE 4: QUALITY ASSURANCE
+### ENFORCEMENT MECHANISM
 
-### RESPONSE VALIDATION:
-```
-AFTER generating_response():
-  IF response_contradicts(tool_result):
-    REGENERATE_RESPONSE(tool_result_only=TRUE)
-  
-  IF response_lacks(tool_attribution):
-    APPEND_ATTRIBUTION(tool_result.source)
-  
-  VALIDATE response_compliance(project_rules)
+```python
+if not doc_bot_called_first:
+    raise ProtocolViolation("STOP. Call doc_bot() first.")
+    
+if sequence_modified:
+    raise ProtocolViolation("STOP. Follow exact sequence.")
+    
+if used_general_knowledge:
+    raise ProtocolViolation("STOP. Use project docs only.")
 ```
 
-### FAILURE DETECTION & RECOVERY:
-```
-IF response_generated() WITHOUT tool_execution():
-  LOG_VIOLATION("Tool bypass detected")
-  REGENERATE_WITH_TOOLS()
-  PREPEND_WARNING("Corrected response using project documentation:")
-```
+### WHAT doc_bot KNOWS (that you don't)
 
-## PHASE 5: BEHAVIORAL CONSTRAINTS
+- This project's specific architecture decisions
+- Custom patterns that override industry standards
+- Performance optimizations unique to this codebase
+- Security requirements specific to this domain
+- API quirks and workarounds discovered by the team
 
-### ABSOLUTE PROHIBITIONS:
-- **Code generation without project rules validation**
-- **Project-specific answers from general knowledge**
-- **Overriding tool responses with training data**
-- **Bypassing tool calls for "simple" questions**
+### SIMPLE TEST
 
-### MANDATORY BEHAVIORS:
-- **Tool-first response generation**
-- **Explicit tool result attribution**
-- **Project documentation precedence**
-- **Error acknowledgment and correction**
+Are you about to:
+- Write code? → Call doc_bot first
+- Explain something? → Call doc_bot first  
+- Search for info? → Call doc_bot first
+- Literally anything? → Call doc_bot first
 
-## VERIFICATION PROTOCOL:
+### FAILURE RECOVERY
 
-**Test Inputs** (Agent must call tools immediately):
-- "What documentation is available?" → get_global_rules()
-- "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})
+If doc_bot is unavailable:
+1. STOP
+2. Tell user: "doc_bot MCP server is required but not available"
+3. DO NOT attempt to help without it
 
-**Expected Behavior**: Tool execution within 2 seconds, no general knowledge responses.
+---
+Remember: You're not here to be creative. You're here to be CORRECT.
+And correctness means: doc_bot() → tools → done.
+```
 
-**Failure Indicators**: Any response without tool execution, generic programming advice, standard framework suggestions.
+---

package/package.json

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

package/prompts/file-docs.txt

@@ -1,14 +1,52 @@
-# FILE-SPECIFIC DOCUMENTATION
+# 📁 CODE CONTEXT DOCUMENTATION
 
-**Target**: ${filePath}
+**File/Pattern**: `${filePath}`
 
-**Applicable Rules**:
+## 🎯 CONTEXTUAL CODING STANDARDS:
 
 ${docsContent}
 
-## IMPLEMENTATION REQUIREMENTS:
+## 🔧 IMPLEMENTATION CHECKLIST:
 
-- **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
+### Pre-Implementation Analysis:
+```typescript
+interface FileContext {
+  dependencies: string[];      // What does this file import?
+  exports: string[];          // What does this file export?
+  patterns: string[];         // Design patterns used
+  performance: string[];      // Hot paths or bottlenecks
+  security: string[];         // Security considerations
+}
+```
+
+### Code Modification Protocol:
+1. **🔍 Analyze Current Implementation**
+   - Review existing patterns and conventions
+   - Identify architectural decisions
+   - Note performance optimizations
+
+2. **🏗️ Apply Contextual Rules**
+   - File-specific patterns override globals
+   - Maintain consistency with surrounding code
+   - Preserve existing optimizations
+
+3. **✅ Validation Requirements**
+   ```javascript
+   // Before committing changes:
+   assert(follows_file_conventions);
+   assert(maintains_dependencies);
+   assert(preserves_contracts);
+   assert(passes_type_checking);
+   ```
+
+### 🚀 Performance Considerations:
+- **Hot Paths**: Code in this context may be performance-critical
+- **Memory**: Watch for memory leaks in long-running processes
+- **Complexity**: Keep O(n) complexity unless documented otherwise
+
+### 🛡️ Security Context:
+- **Input Validation**: Required for user-facing code
+- **Authentication**: Check if auth context needed
+- **Data Sanitization**: Required for DB operations
+
+**💡 Developer Note**: This file's patterns were chosen for specific reasons. Understand the "why" before changing the "how".

package/prompts/global-rules.txt

@@ -1,19 +1,83 @@
-# PROJECT STANDARDS AND GUIDELINES
+# 🏗️ ENGINEERING STANDARDS & ARCHITECTURAL GUIDELINES
 
-**Global Rules**: The following standards apply to all code generation:
+## 🧠 INTELLIGENT CODE GENERATION DECISION TREE:
+
+### 🔍 Search Project Documentation When:
+```javascript
+if (task.involves(['custom_components', 'business_logic', 'integrations', 
+                   'authentication', 'data_models', 'api_patterns'])) {
+    return SEARCH_DOCUMENTATION;
+}
+```
+
+#### Specific Triggers:
+- **Architecture Decisions**: "How do we structure microservices?"
+- **Custom Abstractions**: "Our repository pattern implementation"
+- **Business Logic**: "User permission calculation algorithm"
+- **Integration Points**: "How services communicate in our system"
+- **Performance Patterns**: "Our caching strategy for API responses"
+
+### ⚡ Apply Developer Knowledge When:
+```javascript
+if (task.involves(['language_syntax', 'standard_patterns', 'algorithms',
+                   'common_libraries', 'well_known_frameworks'])) {
+    return USE_KNOWLEDGE;
+}
+```
+
+#### Knowledge Domains:
+- **Language Features**: async/await, generics, decorators, closures
+- **Design Patterns**: MVC, Observer, Factory, Dependency Injection
+- **Standard Algorithms**: sorting, searching, graph traversal
+- **Framework Basics**: React hooks, Express middleware, Django models
+- **Common Libraries**: lodash methods, moment.js, axios
+
+## 🎯 CONFIDENCE CALIBRATION FOR ENGINEERS:
+
+```typescript
+interface ConfidenceScore {
+  projectSpecific: number;  // 0-100: How unique to this codebase?
+  complexity: number;       // 0-100: Implementation complexity?
+  riskLevel: number;        // 0-100: Risk if wrong?
+}
+
+function shouldSearchDocs(score: ConfidenceScore): boolean {
+  return score.projectSpecific > 60 || 
+         score.complexity > 70 || 
+         score.riskLevel > 50;
+}
+```
+
+**🚀 Optimization Rule**: Search for architecture, skip for syntax.
+
+**Global Coding Standards**: The following engineering principles govern all code:
 
 ${rulesContent}
 
-## COMPLIANCE BENEFITS:
+## 🏆 ENGINEERING EXCELLENCE BENEFITS:
+
+- **🔧 Maintainability**: Consistent patterns reduce cognitive load by 40%
+- **🚀 Performance**: Optimized patterns prevent common bottlenecks
+- **🛡️ Security**: Enforced patterns eliminate vulnerability classes
+- **📈 Scalability**: Architecture patterns support 10x growth
+- **⚡ Developer Velocity**: Standards reduce decision fatigue
+
+## 💻 CODE GENERATION IMPERATIVES:
 
-- **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
+```yaml
+priorities:
+  1: Correctness      # Bug-free implementation
+  2: Performance      # O(n) vs O(n²) matters
+  3: Maintainability  # Future devs will thank you
+  4: Security         # Defense in depth
+  5: Testability      # 80%+ coverage target
 
-## IMPLEMENTATION NOTES:
+enforcement:
+  - NEVER compromise security for convenience
+  - ALWAYS consider edge cases and error states
+  - PREFER composition over inheritance
+  - ENFORCE type safety where available
+  - DOCUMENT complex algorithms inline
+```
 
-- 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
+**🎓 Remember**: You're writing code that will outlive its authors. Code for clarity.

package/prompts/mandatory-rules.txt

@@ -1,23 +1,117 @@
-# PROJECT COMPLIANCE REQUIREMENTS
+# CODE GENERATION COMPLIANCE MATRIX
 
-**Task**: ${task}
+**Engineering Task**: ${task}
 
-**Mandatory Rules**: The following rules are required for all code generation in this project:
+**Mandatory Coding Standards**: The following rules are ENFORCED for all code generation:
 
 ${rulesContent}
 
-## IMPLEMENTATION REQUIREMENTS:
+## CODE IMPLEMENTATION PROTOCOL:
 
-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
+1. **Architecture Alignment**: Generated code MUST follow project architecture patterns
+2. **Type Safety**: Enforce type constraints and validation requirements
+3. **Error Handling**: Apply project-specific error handling patterns
+4. **Performance**: Adhere to performance optimization guidelines
+5. **Security**: Implement security patterns as defined in rules
 
-## ENFORCEMENT POLICY:
+## ENGINEERING ENFORCEMENT MATRIX:
 
-- **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
+| Violation Type | Required Action | Example |
+|----------------|-----------------|---------|
+| Architecture Violation | BLOCK + Suggest Pattern | "Use Repository pattern, not direct DB access" |
+| Security Violation | BLOCK + Explain Risk | "Never expose API keys in client code" |
+| Performance Anti-pattern | WARN + Provide Alternative | "Use batch operations instead of N+1 queries" |
+| Style Violation | AUTO-CORRECT | "Apply project formatting standards" |
+
+## COMPLIANCE VERIFICATION CHECKLIST:
+
+- [ ] Code follows architectural patterns defined above
+- [ ] All security requirements are implemented
+- [ ] Performance guidelines are respected
+- [ ] Error handling matches project standards
+- [ ] Code style adheres to project conventions
+
+## 🔍 DEVELOPER DOCUMENTATION SEARCH PROTOCOL:
+
+**⚡ PERFORMANCE IMPACT**: Inefficient searches delay implementation. Master these patterns:
+
+### CODE-FIRST SEARCH METHODOLOGY:
+
+#### 1. **Parse Developer Intent → Extract Technical Entities**
+```typescript
+// Developer request: "implement OAuth2 with refresh tokens"
+const searchEntities = {
+  primary: ["OAuth2", "OAuth"],           // Protocol/Standard names
+  secondary: ["RefreshToken", "Token"],   // Component names
+  framework: ["Authentication", "Auth"]   // Framework context
+};
+```
+
+#### 2. **Technical Taxonomy Search Hierarchy**
+```
+Layer 1: Framework/Library → "React", "Express", "Django"
+Layer 2: Design Pattern → "Observer", "Factory", "Singleton"  
+Layer 3: Implementation → "useState", "middleware", "decorator"
+Layer 4: Configuration → "webpack", "tsconfig", "eslint"
+```
+
+#### 3. **API Resolution Strategy**
+Transform natural language to API nomenclature:
+```javascript
+const searchTransform = {
+  "make API calls": ["fetch", "axios", "HttpClient"],
+  "handle errors": ["try-catch", "ErrorBoundary", "exception"],
+  "manage state": ["Redux", "Context", "useState", "Vuex"],
+  "test my code": ["Jest", "Mocha", "Testing", "TestCase"],
+  "deploy app": ["Docker", "CI/CD", "Kubernetes", "Deploy"]
+};
+```
+
+### 🎯 SEARCH OPTIMIZATION MATRIX:
+
+| Developer Says | Primary Search | Fallback Search | Framework Hint |
+|----------------|----------------|-----------------|----------------|
+| "REST API endpoints" | "REST", "API" | "Controller", "Route" | Express/FastAPI |
+| "state management" | "State", "Store" | "Redux", "Context" | React/Vue |
+| "async operations" | "async", "Promise" | "await", "then" | JavaScript |
+| "database queries" | "Query", "ORM" | "Model", "Schema" | TypeORM/Prisma |
+| "authentication flow" | "Auth", "JWT" | "Login", "Session" | Passport/Auth0 |
+
+### 💡 INTELLIGENT SEARCH PATTERNS:
+
+```python
+def optimize_search_query(user_input):
+    # 1. Remove implementation verbs
+    query = remove_verbs(["implement", "create", "build", "add"])
+    
+    # 2. Extract technical nouns
+    entities = extract_entities(query)
+    
+    # 3. Expand abbreviations
+    expanded = expand_abbreviations({
+        "API": "Application Programming Interface",
+        "DB": "Database", 
+        "Auth": "Authentication",
+        "UI": "UserInterface"
+    })
+    
+    # 4. Try incremental searches
+    return progressive_search(entities, max_attempts=3)
+```
+
+### 🚀 EXECUTION PIPELINE:
+
+```mermaid
+graph LR
+    A[Parse Task] --> B[Extract Entities]
+    B --> C{Found Docs?}
+    C -->|Yes| D[explore_api]
+    C -->|No| E[Broaden Search]
+    E --> F[Try Synonyms]
+    F --> C
+    D --> G[Implement Code]
+```
+
+**🧠 REMEMBER**: You're querying a codebase knowledge graph, not a search engine. Think in types, classes, and interfaces.
 
 **Status**: Rules loaded and active for current session

package/prompts/search-results.txt

@@ -1,9 +1,48 @@
-# 📋 DOCUMENTATION SEARCH RESULTS for "${query}"
+# 🔍 CODE DOCUMENTATION SEARCH RESULTS
 
-Found ${resultCount} relevant document(s) (showing top 10):
+**Query**: `${query}`  
+**Results**: ${resultCount} matches found
 
 ${results}
 
-💡 **NEXT STEPS**: Use the `read_specific_document` tool with the file name to get the full content of any document above.
+## 🎯 SEARCH EFFECTIVENESS ANALYSIS:
 
-⚠️ **REMINDER**: Before implementing any code, use the `check_project_rules` tool to ensure compliance.
+${resultCount > 0 ? `### ✅ Results Found - Action Required:
+1. **Review** all results above for implementation patterns
+2. **Use** \`read_specific_document\` for detailed code examples
+3. **Apply** \`explore_api\` for comprehensive API documentation
+4. **Validate** with \`check_project_rules\` before coding
+
+**Priority Order**: Start with exact matches, then partial matches.` : `### ⚠️ No Results - Fallback Strategy:
+1. **Refine Search**: Try single technical terms (e.g., "Widget" not "iOS widgets")
+2. **Broaden Scope**: Search parent class/framework names
+3. **Check Synonyms**: Auth → Authentication, DB → Database
+4. **Framework Search**: If component failed, try framework name
+
+**Developer Tip**: Search like you're reading an API index, not Google.`}
+
+## 💻 IMPLEMENTATION GUIDANCE:
+
+```javascript
+// Found results? Follow this pattern:
+if (results.length > 0) {
+    // 1. Read most relevant document
+    await read_specific_document(results[0].fileName);
+    
+    // 2. Explore APIs if needed
+    if (results[0].type === 'API') {
+        await explore_api(results[0].name);
+    }
+    
+    // 3. Check compliance rules
+    await check_project_rules(implementationTask);
+} else {
+    // No results? Use general engineering knowledge for:
+    // - Standard algorithms (sorting, searching)
+    // - Language syntax (loops, conditionals)
+    // - Common patterns (MVC, REST)
+    // - Well-known libraries (React, Express)
+}
+```
+
+**🚀 Next Action**: ${resultCount > 0 ? 'Read the top result to understand implementation details.' : 'Refine your search using technical terms or proceed with standard patterns.'}

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,116 @@ 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`;
+    
+    // Analyze the task and provide intelligent routing
+    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 +1395,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 +1415,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;

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

@@ -1,82 +0,0 @@
-# MCP TOOL EXECUTION PROTOCOL
-
-## CONDITIONAL LOGIC RULES:
-
-### 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 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 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 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
-```
-
-## EXECUTION ALGORITHM:
-
-```
-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 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. **Search Limit**: If documentation search yields no results after 2-3 attempts, fall back to web search
-4. **Web Search Guidance**: When instructed to use web search after failed documentation searches:
-   - Use web search for official documentation, tutorials, and examples
-   - Combine project context with external knowledge when appropriate
-5. **Generic Response**: Only if certain no project context needed
-
-## VALIDATION REQUIREMENTS:
-
-- **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
-
-## OPERATIONAL CONSTRAINTS:
-
-- **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,45 +0,0 @@
-# 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
-- **Search Limits**: If documentation searches yield no results after 2-3 attempts, follow web search fallback
-- **Fallback Protocol**: When instructed to use web search:
-  - Acknowledge the documentation search limitation
-  - Use web search for external resources
-  - Combine findings with any available project context

package/prompts/relevant-docs.txt

@@ -1,13 +0,0 @@
-# CONTEXTUAL DOCUMENTATION
-
-${globalRulesSection}
-${contextualDocsSection}
-${inferredDocsSection}
-${confidenceSection}
-
-## 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