@afterxleep/doc-bot 1.9.0 → 1.10.0

package/README.md

@@ -13,6 +13,7 @@ doc-bot is an intelligent documentation server that:
 - 🧠 **Auto-indexes** content for smart inference, based on metadata and keywords
 - 🤖 **Provides agentic tools** to query, and update your documentation
 - 🔄 **Updates** automatically when docs change
+- 📚 **Supports Docsets** for searching official API documentation alongside your custom docs
 
 ## Why MCP Instead of Static Rules?
 
@@ -112,6 +113,18 @@ IDE's use static rule files (like Cursor Rules or Copilot's .github/copilot-inst
      }
    }
    ```
+   
+   **With Docsets support (for official API documentation):**
+   ```json
+   {
+     "mcpServers": {
+       "doc-bot": {
+         "command": "npx",
+         "args": ["@afterxleep/doc-bot@latest", "--docs", "./docs", "--docsets", "~/MyDocSets"]
+       }
+     }
+   }
+   ```
    Note: If a relative path does not work, you can use VSCode `${workspaceFolder}`environment variable `${workspaceFolder}/my-custom-docs`
 
 
@@ -386,6 +399,23 @@ git push origin main
 git push --tags  # Push version tags
 ```
 
+## Docset Support
+
+doc-bot now supports [Docsets](https://kapeli.com/docsets) - pre-indexed documentation used by Dash, Zeal, and Velocity. This allows you to search official API documentation alongside your custom project docs.
+
+### Key Features
+- Search iOS, macOS, Swift, and other official documentation
+- Install docsets from URLs or local files
+- Unified search across both custom docs and official APIs
+- No manual HTML parsing required
+
+### Quick Start
+1. **Install a docset**: Use the `add_docset` tool with a URL or local path
+2. **Search documentation**: Use `search_docsets` for docsets only, or `search_all` for unified results
+3. **Manage docsets**: List installed docsets with `list_docsets`, remove with `remove_docset`
+
+See [DOCSETS.md](./DOCSETS.md) for detailed documentation.
+
 ## License
 
 MIT License - see the [LICENSE](LICENSE) file for details.

package/bin/doc-bot.js

@@ -2,6 +2,7 @@
 
 import { program } from 'commander';
 import path from 'path';
+import os from 'os';
 import fs from 'fs-extra';
 import { DocsServer } from '../src/index.js';
 import { readFileSync } from 'fs';
@@ -17,6 +18,7 @@ program
   .description('Generic MCP server for intelligent documentation access')
   .version(packageJson.version)
   .option('-d, --docs <path>', 'Path to docs folder', 'doc-bot')
+  .option('--docsets <path>', 'Path to docsets folder', path.join(os.homedir(), 'Developer', 'DocSets'))
   .option('-v, --verbose', 'Enable verbose logging')
   .option('-w, --watch', 'Watch for file changes')
   .parse();
@@ -25,6 +27,7 @@ const options = program.opts();
 
 async function main() {
   const docsPath = path.resolve(options.docs);
+  const docsetsPath = path.resolve(options.docsets);
   
   // Check if documentation folder exists
   if (!await fs.pathExists(docsPath)) {
@@ -46,6 +49,7 @@ async function main() {
   
   const server = new DocsServer({
     docsPath,
+    docsetsPath,
     verbose: options.verbose,
     watch: options.watch
   });
@@ -53,6 +57,7 @@ async function main() {
   if (options.verbose) {
     console.error('🚀 Starting doc-bot...');
     console.error(`📁 Documentation: ${docsPath}`);
+    console.error(`📚 Docsets: ${docsetsPath}`);
     console.error(`⚙️  Configuration: Frontmatter-based`);
     
     if (options.watch) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@afterxleep/doc-bot",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "Generic MCP server for intelligent documentation access in any project",
   "type": "module",
   "main": "src/index.js",
@@ -45,7 +45,12 @@
     "chokidar": "^3.5.3",
     "fs-extra": "^11.0.0",
     "glob": "^10.3.0",
-    "yaml": "^2.3.0"
+    "yaml": "^2.3.0",
+    "better-sqlite3": "^11.2.1",
+    "axios": "^1.6.5",
+    "tar": "^6.2.0",
+    "plist": "^3.1.0",
+    "adm-zip": "^0.5.10"
   },
   "devDependencies": {
     "eslint": "^8.57.0",

package/src/__tests__/docset-integration.test.js

@@ -0,0 +1,146 @@
+import { DocsServer } from '../index.js';
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import os from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+describe('DocsServer Docset Integration', () => {
+  let server;
+  let tempDocsPath;
+  let tempDocsetsPath;
+
+  beforeEach(async () => {
+    // Create temporary directories
+    tempDocsPath = path.join(__dirname, 'temp-docs-' + Date.now());
+    tempDocsetsPath = path.join(__dirname, 'temp-docsets-' + Date.now());
+    
+    await fs.ensureDir(tempDocsPath);
+    await fs.ensureDir(tempDocsetsPath);
+    
+    // Create a simple test doc
+    await fs.writeFile(
+      path.join(tempDocsPath, 'test.md'),
+      '---\nalwaysApply: true\ntitle: Test Doc\n---\n# Test'
+    );
+  });
+
+  afterEach(async () => {
+    if (server) {
+      await server.stop();
+    }
+    await fs.remove(tempDocsPath);
+    await fs.remove(tempDocsetsPath);
+  });
+
+  describe('Server initialization with docsets', () => {
+    it('should initialize with custom docsets path', async () => {
+      server = new DocsServer({
+        docsPath: tempDocsPath,
+        docsetsPath: tempDocsetsPath,
+        verbose: false
+      });
+
+      await server.start();
+      
+      expect(server.docsetService).toBeDefined();
+      expect(server.docsetService.storagePath).toBe(tempDocsetsPath);
+    });
+
+    it('should use default docsets path when not provided', async () => {
+      server = new DocsServer({
+        docsPath: tempDocsPath,
+        verbose: false
+      });
+
+      await server.start();
+      
+      const expectedPath = path.join(os.homedir(), 'Developer', 'DocSets');
+      expect(server.docsetService.storagePath).toBe(expectedPath);
+    });
+  });
+
+  describe('Docset service functionality', () => {
+    beforeEach(async () => {
+      server = new DocsServer({
+        docsPath: tempDocsPath,
+        docsetsPath: tempDocsetsPath,
+        verbose: false
+      });
+      await server.start();
+    });
+
+    it('should have docset service initialized', () => {
+      expect(server.docsetService).toBeDefined();
+      expect(server.docsetDatabase).toBeDefined();
+    });
+
+    it('should have empty docsets initially', async () => {
+      const docsets = await server.docsetService.listDocsets();
+      expect(docsets).toEqual([]);
+    });
+
+    it('should handle docset operations', async () => {
+      // Create a mock docset
+      const mockDocsetPath = path.join(tempDocsetsPath, 'Mock.docset');
+      const contentsPath = path.join(mockDocsetPath, 'Contents');
+      const resourcesPath = path.join(contentsPath, 'Resources');
+      
+      await fs.ensureDir(resourcesPath);
+      
+      // Create Info.plist
+      const infoPlist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key>
+  <string>Mock Documentation</string>
+  <key>CFBundleIdentifier</key>
+  <string>mock.documentation</string>
+</dict>
+</plist>`;
+      await fs.writeFile(path.join(contentsPath, 'Info.plist'), infoPlist);
+      
+      // Create SQLite database
+      const Database = (await import('better-sqlite3')).default;
+      const dbPath = path.join(resourcesPath, 'docSet.dsidx');
+      const db = new Database(dbPath);
+      db.exec(`
+        CREATE TABLE searchIndex(
+          id INTEGER PRIMARY KEY,
+          name TEXT,
+          type TEXT,
+          path TEXT
+        );
+      `);
+      db.prepare('INSERT INTO searchIndex (name, type, path) VALUES (?, ?, ?)')
+        .run('TestClass', 'Class', 'test.html');
+      db.close();
+      
+      // Test adding docset
+      const docsetInfo = await server.docsetService.addDocset(mockDocsetPath);
+      expect(docsetInfo.name).toBe('Mock Documentation');
+      
+      // Test listing docsets
+      const docsets = await server.docsetService.listDocsets();
+      expect(docsets).toHaveLength(1);
+      expect(docsets[0].name).toBe('Mock Documentation');
+      
+      // Add to database for searching
+      server.docsetDatabase.addDocset(docsetInfo);
+      
+      // Test searching
+      const searchResults = server.docsetDatabase.search('Test');
+      expect(searchResults).toHaveLength(1);
+      expect(searchResults[0].name).toBe('TestClass');
+      
+      // Test removing docset
+      await server.docsetService.removeDocset(docsetInfo.id);
+      const finalDocsets = await server.docsetService.listDocsets();
+      expect(finalDocsets).toHaveLength(0);
+    });
+  });
+});

package/src/index.js

@@ -3,8 +3,11 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { DocumentationService } from './services/DocumentationService.js';
 import { InferenceEngine } from './services/InferenceEngine.js';
+import { DocsetService } from './services/docset/index.js';
+import { MultiDocsetDatabase } from './services/docset/database.js';
 import chokidar from 'chokidar';
 import path from 'path';
+import os from 'os';
 import { promises as fs } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
@@ -16,6 +19,7 @@ class DocsServer {
   constructor(options = {}) {
     this.options = {
       docsPath: options.docsPath || './doc-bot',
+      docsetsPath: options.docsetsPath || path.join(os.homedir(), 'Developer', 'DocSets'),
       verbose: options.verbose || false,
       watch: options.watch || false,
       ...options
@@ -38,6 +42,10 @@ class DocsServer {
     this.docService = new DocumentationService(this.options.docsPath);
     this.inferenceEngine = new InferenceEngine(this.docService);
     
+    // Initialize docset services
+    this.docsetService = new DocsetService(this.options.docsetsPath);
+    this.docsetDatabase = new MultiDocsetDatabase();
+    
     this.setupHandlers();
     
     if (this.options.watch) {
@@ -252,6 +260,95 @@ class DocsServer {
               properties: {},
               additionalProperties: false
             }
+          },
+          // Docset tools
+          {
+            name: 'add_docset',
+            description: 'Add a new documentation set from a URL or local file path. Supports .docset directories, .tgz/.tar.gz/.zip archives.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                source: {
+                  type: 'string',
+                  description: 'URL to download docset from OR local file path. Example: https://example.com/iOS.tgz or /path/to/Swift.docset'
+                }
+              },
+              required: ['source']
+            }
+          },
+          {
+            name: 'remove_docset',
+            description: 'Remove an installed documentation set',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                docsetId: {
+                  type: 'string',
+                  description: 'ID of the docset to remove'
+                }
+              },
+              required: ['docsetId']
+            }
+          },
+          {
+            name: 'list_docsets',
+            description: 'List all installed documentation sets',
+            inputSchema: {
+              type: 'object',
+              properties: {}
+            }
+          },
+          {
+            name: 'search_docsets',
+            description: 'Search installed documentation sets for API references, classes, methods, and guides. Returns official documentation with direct file links.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                query: {
+                  type: 'string',
+                  description: 'Search query - can be class names, method names, concepts, or any technical term'
+                },
+                type: {
+                  type: 'string',
+                  description: 'Optional: filter by type (Class, Method, Function, Guide, Property, Protocol, Enum, etc.)',
+                  enum: ['Class', 'Method', 'Function', 'Property', 'Protocol', 'Enum', 'Structure', 'Guide', 'Sample', 'Category', 'Constant', 'Variable', 'Typedef', 'Macro']
+                },
+                docsetId: {
+                  type: 'string',
+                  description: 'Optional: limit search to specific docset ID'
+                },
+                limit: {
+                  type: 'number',
+                  description: 'Maximum results to return (default: 50)',
+                  minimum: 1,
+                  maximum: 200,
+                  default: 50
+                }
+              },
+              required: ['query']
+            }
+          },
+          {
+            name: 'docset_stats',
+            description: 'Get detailed statistics about installed documentation sets',
+            inputSchema: {
+              type: 'object',
+              properties: {}
+            }
+          },
+          {
+            name: 'search_all',
+            description: 'Search both Markdown documentation and installed docsets. Provides unified results from all sources.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                query: {
+                  type: 'string',
+                  description: 'Search query to find in both documentation types'
+                }
+              },
+              required: ['query']
+            }
           }
         ]
       };
@@ -368,6 +465,134 @@ class DocsServer {
               }]
             };
             
+          // Docset tools
+          case 'add_docset':
+            const { source } = args || {};
+            if (!source) {
+              throw new Error('source parameter is required');
+            }
+            
+            try {
+              const docsetInfo = await this.docsetService.addDocset(source);
+              this.docsetDatabase.addDocset(docsetInfo);
+              
+              return {
+                content: [{
+                  type: 'text',
+                  text: JSON.stringify({
+                    success: true,
+                    docset: docsetInfo,
+                    message: `Successfully added docset: ${docsetInfo.name}`
+                  }, null, 2)
+                }]
+              };
+            } catch (error) {
+              return {
+                content: [{
+                  type: 'text',
+                  text: JSON.stringify({
+                    success: false,
+                    error: error.message
+                  }, null, 2)
+                }]
+              };
+            }
+            
+          case 'remove_docset':
+            const { docsetId } = args || {};
+            if (!docsetId) {
+              throw new Error('docsetId parameter is required');
+            }
+            
+            try {
+              await this.docsetService.removeDocset(docsetId);
+              this.docsetDatabase.removeDocset(docsetId);
+              
+              return {
+                content: [{
+                  type: 'text',
+                  text: JSON.stringify({
+                    success: true,
+                    message: `Successfully removed docset: ${docsetId}`
+                  }, null, 2)
+                }]
+              };
+            } catch (error) {
+              return {
+                content: [{
+                  type: 'text',
+                  text: JSON.stringify({
+                    success: false,
+                    error: error.message
+                  }, null, 2)
+                }]
+              };
+            }
+            
+          case 'list_docsets':
+            const docsets = await this.docsetService.listDocsets();
+            
+            return {
+              content: [{
+                type: 'text',
+                text: JSON.stringify(docsets, null, 2)
+              }]
+            };
+            
+          case 'search_docsets':
+            const { query: docsetQuery, type, docsetId: searchDocsetId, limit } = args || {};
+            if (!docsetQuery) {
+              throw new Error('query parameter is required');
+            }
+            
+            const docsetResults = this.docsetDatabase.search(docsetQuery, { type, docsetId: searchDocsetId, limit });
+            
+            return {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  query: docsetQuery,
+                  resultCount: docsetResults.length,
+                  results: docsetResults
+                }, null, 2)
+              }]
+            };
+            
+          case 'docset_stats':
+            const stats = this.docsetDatabase.getStats();
+            
+            return {
+              content: [{
+                type: 'text',
+                text: JSON.stringify(stats, null, 2)
+              }]
+            };
+            
+          case 'search_all':
+            const { query: allQuery } = args || {};
+            if (!allQuery) {
+              throw new Error('query parameter is required');
+            }
+            
+            // Search markdown documentation
+            const markdownResults = await this.docService.searchDocuments(allQuery);
+            
+            // Search docsets
+            const allDocsetResults = this.docsetDatabase.search(allQuery, { limit: 50 });
+            
+            return {
+              content: [{
+                type: 'text',
+                text: JSON.stringify({
+                  query: allQuery,
+                  sources: ['markdown', 'docsets'],
+                  markdownResults: markdownResults.slice(0, 10),
+                  docsetResults: allDocsetResults,
+                  totalResults: markdownResults.length + allDocsetResults.length
+                }, null, 2)
+              }]
+            };
+            
           default:
             throw new Error(`Unknown tool: ${name}`);
         }
@@ -839,6 +1064,19 @@ class DocsServer {
     await this.docService.initialize();
     await this.inferenceEngine.initialize();
     
+    // Initialize docset service
+    await this.docsetService.initialize();
+    
+    // Load existing docsets into the database
+    const existingDocsets = await this.docsetService.listDocsets();
+    for (const docset of existingDocsets) {
+      this.docsetDatabase.addDocset(docset);
+    }
+    
+    if (this.options.verbose && existingDocsets.length > 0) {
+      console.error(`📚 Loaded ${existingDocsets.length} docsets from ${this.docsetService.storagePath}`);
+    }
+    
     // Start server
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
@@ -848,6 +1086,13 @@ class DocsServer {
       console.error('🚀 Using frontmatter-based configuration');
     }
   }
+  
+  async stop() {
+    if (this.docsetDatabase) {
+      this.docsetDatabase.closeAll();
+    }
+    await this.server.close();
+  }
 }
 
 export { DocsServer };