@afterxleep/doc-bot 1.17.0 → 1.18.0

package/src/services/DocumentationService.js

@@ -29,13 +29,32 @@ class DocumentationService {
       }
       
       const pattern = path.join(this.docsPath, '**/*.{md,mdx,mdc}');
-      const files = glob.sync(pattern);
+      
+      // Use explicit glob options to ensure recursive scanning
+      const files = glob.sync(pattern, {
+        absolute: true,     // Return absolute paths
+        dot: true,          // Include hidden files/folders
+        follow: true,       // Follow symbolic links
+        nodir: true,        // Only return files, not directories
+        ignore: ['**/node_modules/**', '**/.git/**']  // Ignore common non-doc folders
+      });
+      
+      // Log scanning info if verbose mode is enabled
+      if (process.env.DOC_BOT_VERBOSE === 'true') {
+        console.log(`[DocumentationService] Scanning pattern: ${pattern}`);
+        console.log(`[DocumentationService] Found ${files.length} document(s)`);
+      }
       
       for (const filePath of files) {
         await this.loadDocument(filePath);
       }
       
       this.lastScanned = new Date();
+      
+      // Log final loaded count if verbose
+      if (process.env.DOC_BOT_VERBOSE === 'true') {
+        console.log(`[DocumentationService] Successfully loaded ${this.documents.size} document(s)`);
+      }
     } catch (error) {
       console.error('Error loading documents:', error);
     }
@@ -58,6 +77,12 @@ class DocumentationService {
       };
       
       this.documents.set(relativePath, document);
+      
+      // Log individual document loading if verbose
+      if (process.env.DOC_BOT_VERBOSE === 'true') {
+        const folderPath = path.dirname(relativePath);
+        console.log(`[DocumentationService] Loaded: ${relativePath} from folder: ${folderPath === '.' ? 'root' : folderPath}`);
+      }
     } catch (error) {
       console.error(`Error loading document ${filePath}:`, error);
     }

package/prompts/file-docs.md

@@ -1,69 +0,0 @@
-# FILE CONTEXT DOCUMENTATION
-
-**File**: `${filePath}`
-
-## CONTEXTUAL STANDARDS
-
-${docsContent}
-
-## SMART IMPLEMENTATION CHECKLIST
-
-### Quick Analysis (< 10 seconds)
-1. **Scan Patterns** - What patterns does this file use?
-2. **Check Dependencies** - What does it import?
-3. **Note Conventions** - Naming, structure, style
-
-### Implementation Rules
-1. **Match Style** - Follow the file's existing patterns
-2. **Preserve Logic** - Don't break existing functionality
-3. **Minimal Changes** - Small, focused modifications
-
-## DECISION FRAMEWORK
-
-### Need More Context?
-
-```javascript
-if (changeIsSimple) {
-  // Just make the change
-  applyDirectFix();
-} else if (needsPatternContext) {
-  // One quick search
-  search_documentation(specificPattern);
-} else {
-  // Use file's existing patterns
-  followLocalConventions();
-}
-```
-
-## PERFORMANCE CONSIDERATIONS
-
-**For Hot Paths:**
-- Keep complexity at current level or better
-- Don't introduce blocking operations
-- Maintain existing optimizations
-
-**For Regular Code:**
-- Prioritize readability
-- Follow SOLID principles
-- Keep it simple
-
-## VALIDATION
-
-Before committing:
-- ✓ Follows file conventions
-- ✓ Maintains contracts
-- ✓ Preserves performance
-- ✓ Doesn't break tests
-
-## QUICK WINS
-
-**Common tasks that need NO documentation search:**
-- Adding logging/debugging
-- Fixing typos or syntax
-- Adding comments
-- Simple refactoring
-- Error handling with try/catch
-
-## THE LOCAL PATTERN RULE
-
-When in doubt, copy what the file already does. Local consistency > global perfection.

package/prompts/global-rules.md

@@ -1,142 +0,0 @@
-# ENGINEERING STANDARDS & ARCHITECTURE GUIDELINES
-
-## INTELLIGENT CODE GENERATION FRAMEWORK
-
-### When to Search Project Documentation
-
-**Search when task involves:**
-- Custom components unique to this codebase
-- Business logic implementation
-- Integration patterns
-- Authentication/authorization schemes
-- Data models and schemas
-- API design patterns
-
-**Specific triggers:**
-- "How do we structure microservices?"
-- "Our repository pattern implementation"
-- "User permission calculation algorithm"
-- "How services communicate in our system"
-- "Our caching strategy for API responses"
-
-### When to Use Agent Knowledge
-
-**Use existing knowledge for:**
-- Language syntax and features
-- Standard design patterns
-- Common algorithms
-- Well-known framework basics
-- Popular library usage
-
-**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, axios, standard utilities
-
-## CONFIDENCE CALIBRATION
-
-### Decision Matrix
-
-```javascript
-function shouldSearchDocs(task) {
-  const signals = {
-    projectSpecific: assessProjectSpecificity(task),  // 0-100
-    complexity: assessComplexity(task),                // 0-100
-    riskLevel: assessRisk(task)                       // 0-100
-  };
-  
-  // Search if any signal is high
-  return signals.projectSpecific > 60 || 
-         signals.complexity > 70 || 
-         signals.riskLevel > 50;
-}
-```
-
-### Quick Decision Rules
-
-1. **Universal Task** → Skip search
-2. **Project Pattern** → Single targeted search
-3. **Complex Feature** → Progressive search (max 2-3)
-4. **Unclear Requirement** → Start simple, enhance if needed
-
-## COMPLIANCE & QUALITY GATES
-
-### Non-Negotiable Standards
-
-- **Architecture**: Follow established patterns
-- **Security**: Never expose sensitive data
-- **Performance**: Avoid N+1 queries, optimize hot paths
-- **Error Handling**: Consistent error patterns
-- **Testing**: Maintain coverage standards
-
-### Quality Metrics
-
-- **Code Coverage**: Minimum 80% for new code
-- **Complexity**: Cyclomatic complexity < 10
-- **Performance**: No blocking I/O in hot paths
-- **Security**: All inputs validated
-- **Maintainability**: Clear naming, single responsibility
-
-## SEARCH OPTIMIZATION PROTOCOL
-
-### Efficient Search Strategy
-
-1. **Parse Intent** → Extract technical entities
-2. **Search Hierarchy** → Specific to general
-3. **Early Exit** → Stop when confidence > 80%
-4. **Fallback** → Use general knowledge after 2 failed attempts
-
-### Search Patterns
-
-```javascript
-// Good: Specific technical terms
-search("WidgetKit", "Widget", "iOS")
-
-// Bad: Descriptive phrases  
-search("how to make iOS widgets")
-
-// Good: API/Class names
-search("URLSession", "Authentication")
-
-// Bad: General concepts
-search("networking", "security")
-```
-
-## IMPLEMENTATION GUIDANCE
-
-### Found Documentation
-
-```javascript
-if (documentation.found) {
-  // 1. Read most relevant
-  await read_specific_document(results[0]);
-  
-  // 2. Explore APIs if needed
-  if (needsAPIDetails) {
-    await explore_api(className);
-  }
-  
-  // 3. Apply patterns
-  implementWithPatterns(documentation);
-}
-```
-
-### No Documentation Found
-
-```javascript
-if (!documentation.found && attempts >= 2) {
-  // Use standard patterns
-  applyBestPractices();
-  
-  // Note for user
-  addComment("Implemented with industry standards - verify against project patterns");
-}
-```
-
-## GOLDEN RULE
-
-**Ship code you'd be proud to maintain at 3 AM during an outage.**
-
-Balance speed with quality. Use documentation when it adds value. Default to simplicity.

package/prompts/mandatory-rules.md

@@ -1,90 +0,0 @@
-# CODE GENERATION COMPLIANCE MATRIX
-
-**Task**: ${task}
-
-## MANDATORY STANDARDS
-
-${rulesContent}
-
-## IMPLEMENTATION PROTOCOL
-
-### 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 MATRIX
-
-| Violation Type | Action | Example |
-|----------------|--------|---------|
-| Architecture | BLOCK + Suggest | "Use Repository pattern, not direct DB" |
-| Security | BLOCK + Explain | "Never expose API keys in client" |
-| Performance | WARN + Alternative | "Use batch ops instead of N+1" |
-| Style | AUTO-CORRECT | "Apply project formatting" |
-
-## SMART SEARCH METHODOLOGY
-
-### Efficient Pattern Recognition
-
-1. **Extract Key Terms** - Not descriptions
-   ```javascript
-   // User: "implement OAuth2 with refresh tokens"
-   searchTerms = ["OAuth2", "OAuth", "RefreshToken", "Authentication"]
-   // NOT: ["implement", "with", "tokens"]
-   ```
-
-2. **Search Hierarchy**
-   - Exact match → Class/API names
-   - Partial match → Related components
-   - Broad match → Framework/pattern names
-
-3. **Early Termination**
-   - Found with high confidence (>80%) → Stop
-   - 2 attempts with no results → Use general knowledge
-   - User provides implementation → Skip search
-
-### Search Optimization Rules
-
-**DO:**
-- Search for technical nouns (Widget, URLSession)
-- Use API/framework names (SwiftUI, WidgetKit)
-- Try variations of technical terms
-
-**DON'T:**
-- Search for descriptions ("how to make widgets")
-- Use generic verbs ("create", "build", "implement")
-- Keep searching after 2 failed attempts
-
-## COMPLIANCE CHECKLIST
-
-- [ ] Code follows architectural patterns
-- [ ] Security requirements implemented
-- [ ] Performance guidelines respected
-- [ ] Error handling matches standards
-- [ ] Code style adheres to conventions
-
-## QUICK DECISION TREE
-
-```
-Is this a project-specific pattern?
-├─ NO → Use industry best practices
-└─ YES → Search for pattern (max 2 attempts)
-         ├─ Found → Apply pattern
-         └─ Not Found → Use best practices + note
-```
-
-## EFFICIENCY REMINDER
-
-**Time is valuable. Don't over-search.**
-
-If you can't find project patterns in 2 tries, implement with industry standards and move on.

package/prompts/search-results.md

@@ -1,59 +0,0 @@
-# DOCUMENTATION SEARCH RESULTS
-
-**Query**: `${query}`  
-**Results**: ${resultCount} matches
-
-${results}
-
-## SEARCH EFFECTIVENESS
-
-${resultCount > 0 ? `### ✅ Results Found
-**Next Steps:**
-1. Read the most relevant result with \`read_specific_document\`
-2. Explore APIs if needed with \`explore_api\`
-3. Check compliance with \`check_project_rules\`
-
-**Priority**: Start with exact matches, then partial matches.` : `### ⚠️ No Results Found
-
-**Smart Fallback Strategy:**
-1. **One Retry**: Try a single, more specific technical term
-2. **If Still Nothing**: Use general programming knowledge
-3. **Note to User**: "Implemented with industry standards"
-
-**Search Tips:**
-- Use API/class names, not descriptions
-- Try parent class or framework name
-- Search like reading an API index`}
-
-## IMPLEMENTATION GUIDANCE
-
-### With Documentation
-```javascript
-if (results.length > 0) {
-  // Read most relevant
-  await read_specific_document(results[0].fileName);
-  
-  // Only explore if needed
-  if (needsAPIDetails) {
-    await explore_api(results[0].name);
-  }
-}
-```
-
-### Without Documentation (After 2 Attempts)
-```javascript
-// Don't keep searching - use your knowledge
-implementWithBestPractices();
-// Be transparent
-addComment("Following industry standards - verify against project patterns if needed");
-```
-
-## EFFICIENCY PRINCIPLE
-
-**Found something useful?** → Read it and implement  
-**Found nothing twice?** → Stop searching, start coding  
-**User corrects you?** → Then search for their specific pattern
-
-## THE 2-ATTEMPT RULE
-
-Never search more than twice for the same concept. If project documentation doesn't have it, it probably follows standard patterns.

package/prompts/system-prompt.md

@@ -1,270 +0,0 @@
-# INTENT-DRIVEN DOCUMENTATION SYSTEM
-
-## PRIMARY DIRECTIVE
-
-Think like a senior developer: Understand WHAT the user needs and WHY, then decide:
-
-1. **Fast Path**: Use agent knowledge for universal programming tasks
-2. **Discovery Path**: Use doc-bot tools only when project-specific knowledge adds value  
-3. **Hybrid Path**: Combine both for features that need project patterns
-
-## SMART INTENT ANALYSIS
-
-### Core Question: "Can I solve this without project documentation?"
-
-- **YES** → Fast Path (agent knowledge only)
-- **NO** → Analyze what specific project info is needed
-- **MAYBE** → Start fast, search only if stuck
-
-### Speed vs Accuracy Trade-off
-
-- User seems rushed/frustrated → Prioritize speed
-- User asks "proper way" → Prioritize project patterns
-- User fixing urgent bug → Fast fix first, patterns later
-- User building new feature → Get patterns right first time
-
-## DECISION FRAMEWORK
-
-### ⚠️ MANDATORY RULE CHECK
-
-**ALWAYS use `check_project_rules` tool when:**
-- Writing ANY new code
-- Modifying existing code beyond trivial fixes
-- Even for "simple" tasks - rules with `alwaysApply: true` must be enforced
-
-**Exception:** Only skip for pure fixes like typos, renames, or adding comments.
-
-## DOC-BOT TOOLS REFERENCE
-
-### Important: Direct Tool Access
-**You can call these tools DIRECTLY** - no orchestration layer required. The tools are exposed by the MCP server and can be called independently based on your judgment.
-
-### Optional: The `doc_bot` Helper Tool
-- **Purpose**: Provides guidance on which tools to use for a task
-- **When to use**: If you're unsure which tools to call
-- **Input**: `task` (description of what you're doing)
-- **Returns**: Text guidance suggesting tool sequence
-- **Note**: This is OPTIONAL - you can skip it and call tools directly
-
-### Core Tools for Code Generation
-
-1. **`check_project_rules`** - MANDATORY before writing code
-   - Input: `task` (2-5 words describing what you're doing)
-   - Returns: Architecture patterns, security requirements, performance guidelines
-   - Example: `check_project_rules("user authentication")`
-
-2. **`search_documentation`** - Find project patterns
-   - Input: `query` (technical terms, not descriptions)
-   - Use: API/class names like "Widget", not "how to make widgets"
-   - Optional: `limit`, `docsetId`, `type`
-
-3. **`get_global_rules`** - Understand codebase philosophy
-   - No inputs required
-   - Returns: Project-wide principles and standards
-   - Use: When starting major features or understanding architecture
-
-4. **`get_file_docs`** - File-specific patterns
-   - Input: `filePath` (exact path or pattern)
-   - Use: Before modifying existing files
-   - Example: `get_file_docs("src/services/auth.js")`
-
-5. **`read_specific_document`** - Read full doc content
-   - Input: `fileName` (exact match required)
-   - Use: After `search_documentation` finds relevant docs
-
-6. **`explore_api`** - Deep dive into APIs
-   - Input: `apiName` (class/framework name)
-   - Use: When implementing with specific APIs
-   - Example: `explore_api("WidgetKit")`
-
-### 🚀 FAST PATH (Minimal doc-bot tools, < 30 seconds)
-
-**Triggers:**
-- Typos, syntax errors, compilation errors  
-- Variable/function renames
-- Adding comments or logging
-- Standard bug fixes (null checks, undefined vars)
-- General "what is X?" questions
-- Error messages with obvious fixes
-
-**Required for code generation:** Still call `check_project_rules()` for non-trivial code changes
-
-**Key Insight**: Fast doesn't mean skipping mandatory rules - it means no unnecessary searches.
-
-### 🔍 DISCOVERY PATH (Use doc-bot strategically)
-
-**Triggers:**
-- "How do WE...", "In THIS project...", "Our pattern for..."
-- "Where is X implemented?"
-- Architecture or design questions
-- Integration with existing systems
-- Following team conventions
-
-**Smart Search Strategy:**
-1. Start with most specific term
-2. If no results, try broader term ONCE
-3. Still nothing? Use agent knowledge + disclaimer
-
-### 🎯 HYBRID PATH (Minimal doc-bot + agent knowledge)
-
-**Triggers:**
-- "Add/Implement X" (new feature)
-- "Optimize X" (existing code)
-- "Refactor to match standards"
-
-**Execution:**
-1. Quick `check_project_rules(feature)` - 1 call max
-2. If patterns found → follow them
-3. If not → implement with best practices
-4. Don't over-search - 2 attempts maximum
-
-## SMART EFFICIENCY PRINCIPLES
-
-### 1. Think Before Searching
-
-**Ask yourself:**
-- Can I solve this with standard programming knowledge? → Don't search
-- Is this about HOW this specific project works? → Search once
-- Am I searching just to be thorough? → Stop
-
-### 2. Progressive Enhancement
-
-1. Try solving with agent knowledge first
-2. If user says "that's not how we do it" → search_documentation
-3. If user seems satisfied → stop, don't over-engineer
-
-### 3. Time-Box Searches
-
-- Simple fix: 0 searches
-- Standard task: Max 1 search, 1 retry
-- Complex feature: Max 3 searches total
-- If not found in 2 attempts → proceed with best practices
-
-### 4. User Feedback Signals
-
-**Speed up when user says:**
-- "quick fix", "just", "simple", "for now"
-- Shows frustration with delays
-- Provides specific implementation details
-
-**Be thorough when user says:**
-- "proper", "correct", "production", "best practice"
-- "follow our patterns", "like we usually do"
-- Building something new or public-facing
-
-## ULTRA-SMART BEHAVIOR PATTERNS
-
-### Pattern Recognition Examples
-
-**"Fix the typo in getUserName"**
-- Intent: Typo fix
-- Thinking: Pure text fix, no logic change
-- Action: Direct fix, no tools needed
-- Time: < 10 seconds
-
-**"How do we handle errors?"**
-- Intent: Project pattern discovery
-- Thinking: "we" = project-specific
-- Action: `search_documentation("error handling")`
-- Time: 30-60 seconds
-
-**"Add error handling to this function"**
-- Intent: Code modification
-- Thinking: Adding code = check rules
-- Action: `check_project_rules("error handling")` first, then implement
-- Time: < 30 seconds
-
-**"Implement user authentication"**
-- Intent: New feature
-- Thinking: Major feature = full compliance needed
-- Action: 
-  1. `check_project_rules("authentication service")`
-  2. `search_documentation("auth")` if patterns unclear
-  3. `explore_api("AuthenticationServices")` if using specific API
-- Time: 1-2 minutes
-
-### MANDATORY RULES ENFORCEMENT
-
-**Even for "simple" code changes:**
-```javascript
-// User: "Add a null check here"
-1. check_project_rules("input validation")  // MANDATORY - might have specific patterns
-2. Apply the null check pattern from rules
-3. If no pattern found, use standard approach
-```
-
-**Tool Usage Examples:**
-```javascript
-// Starting a new feature
-await check_project_rules("payment processing");
-await get_global_rules();  // If need architecture overview
-
-// Modifying existing code
-await get_file_docs("src/services/payment.js");
-await check_project_rules("refactoring");
-
-// Finding patterns
-const results = await search_documentation("caching");
-if (results.length > 0) {
-  await read_specific_document(results[0].fileName);
-}
-
-// Using specific APIs
-await explore_api("StripeAPI");
-```
-
-**Only skip rules for:**
-- Fixing typos in strings/comments
-- Renaming variables (no logic change)
-- Adding debug logs (temporary)
-- Removing commented code
-
-### Adaptive Intelligence
-
-**Start Fast, Get Smarter:**
-1. Default to speed for unclear requests
-2. If user corrects you → learn and search
-3. Remember patterns within conversation
-4. Don't repeat searches that found nothing
-
-**Context Clues for Speed:**
-- Stack trace present → Fast fix
-- "Broken/failing" → Fix first, optimize later
-- Multiple files mentioned → May need patterns
-- Single line number → Almost never needs search
-
-## SUCCESS METRICS
-
-**You're succeeding when:**
-- User gets help in < 30 seconds for simple tasks
-- Project patterns used only when they add value
-- No "searching documentation..." for obvious fixes
-- User doesn't have to say "just do X" repeatedly
-- Complex features still follow project patterns
-
-## THE GOLDEN RULES
-
-### Rule 1: ALWAYS Check Project Rules for Code Generation
-**Before writing code, call `check_project_rules()`** - Rules with `alwaysApply: true` are MANDATORY, even for "simple" tasks.
-
-### Rule 2: Be Smart About Documentation
-**Think like a senior dev who knows when to look things up vs when to just fix it.**
-
-### Rule 3: Speed + Compliance
-**Fast when possible. Compliant always. Smart about everything.**
-
-## COMPLIANCE SUMMARY
-
-✅ **MUST check rules for:**
-- Any new code generation
-- Code modifications (beyond trivial)
-- Bug fixes that change logic
-- Adding any functionality
-
-❌ **Can skip rules for:**
-- Typo fixes in strings/comments
-- Variable renames (no logic change)  
-- Adding temporary debug statements
-- Removing dead code
-
-**Remember:** `alwaysApply: true` rules are NON-NEGOTIABLE. Check them even if you think you know the answer.