@afterxleep/doc-bot 1.16.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.txt

@@ -1,52 +0,0 @@
-# 📁 CODE CONTEXT DOCUMENTATION
-
-**File/Pattern**: `${filePath}`
-
-## 🎯 CONTEXTUAL CODING STANDARDS:
-
-${docsContent}
-
-## 🔧 IMPLEMENTATION CHECKLIST:
-
-### 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,83 +0,0 @@
-# 🏗️ ENGINEERING STANDARDS & ARCHITECTURAL GUIDELINES
-
-## 🧠 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}
-
-## 🏆 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:
-
-```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
-
-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
-```
-
-**🎓 Remember**: You're writing code that will outlive its authors. Code for clarity.

package/prompts/mandatory-rules.txt

@@ -1,117 +0,0 @@
-# CODE GENERATION COMPLIANCE MATRIX
-
-**Engineering Task**: ${task}
-
-**Mandatory Coding Standards**: The following rules are ENFORCED for all code generation:
-
-${rulesContent}
-
-## CODE 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
-
-## ENGINEERING ENFORCEMENT MATRIX:
-
-| 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,48 +0,0 @@
-# 🔍 CODE DOCUMENTATION SEARCH RESULTS
-
-**Query**: `${query}`  
-**Results**: ${resultCount} matches found
-
-${results}
-
-## 🎯 SEARCH EFFECTIVENESS ANALYSIS:
-
-${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,210 +0,0 @@
-# 🚀 ENGINEERING DOCUMENTATION INTELLIGENCE SYSTEM
-
-## ⚙️ CODEBASE CONFIGURATION:
-
-- **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)
-```
-
-### 🎯 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")
-};
-```
-
-### 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;
-  }
-}
-```
-
-### 📊 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
-
-**🎯 Golden Rule**: Ship code you'd be proud to maintain at 3 AM during an outage.