@telvok/librarian-mcp 1.5.3 → 2.0.0

package/dist/server.js

@@ -2,12 +2,85 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { LibrarianError } from './library/errors.js';
 import { briefTool } from './tools/brief.js';
 import { recordTool } from './tools/record.js';
 import { adoptTool } from './tools/adopt.js';
 import { markHitTool } from './tools/mark-hit.js';
 import { importMemoriesTool } from './tools/import-memories.js';
 import { rebuildIndexTool } from './tools/rebuild-index.js';
+import { authTool } from './tools/auth.js';
+import { librarySearchTool } from './tools/library-search.js';
+import { libraryBuyTool } from './tools/library-buy.js';
+import { libraryDownloadTool } from './tools/library-download.js';
+import { libraryPublishTool } from './tools/library-publish.js';
+import { myBooksTool } from './tools/my-books.js';
+import { syncTool } from './tools/sync.js';
+import { sellerAnalyticsTool } from './tools/seller-analytics.js';
+import { rateBookTool } from './tools/rate-book.js';
+import { helpTool } from './tools/help.js';
+import { feedbackTool } from './tools/feedback.js';
+import { bountyCreateTool } from './tools/bounty-create.js';
+import { bountyListTool } from './tools/bounty-list.js';
+import { bountyClaimTool } from './tools/bounty-claim.js';
+import { bountySubmitTool } from './tools/bounty-submit.js';
+import { myBountiesTool } from './tools/my-bounties.js';
+import { deleteTool } from './tools/delete.js';
+import { unsubscribeTool } from './tools/unsubscribe.js';
+const allTools = [
+    // Core tools — local knowledge management
+    { tool: briefTool, group: 'core' },
+    { tool: recordTool, group: 'core' },
+    { tool: adoptTool, group: 'core' },
+    { tool: markHitTool, group: 'core' },
+    { tool: importMemoriesTool, group: 'core' },
+    { tool: rebuildIndexTool, group: 'core' },
+    { tool: deleteTool, group: 'core' },
+    // Marketplace tools — cloud features
+    { tool: librarySearchTool, group: 'marketplace' },
+    { tool: libraryBuyTool, group: 'marketplace' },
+    { tool: libraryDownloadTool, group: 'marketplace' },
+    { tool: libraryPublishTool, group: 'marketplace' },
+    { tool: myBooksTool, group: 'marketplace' },
+    { tool: syncTool, group: 'marketplace' },
+    { tool: sellerAnalyticsTool, group: 'marketplace' },
+    { tool: rateBookTool, group: 'marketplace' },
+    { tool: bountyCreateTool, group: 'marketplace' },
+    { tool: bountyListTool, group: 'marketplace' },
+    { tool: bountyClaimTool, group: 'marketplace' },
+    { tool: bountySubmitTool, group: 'marketplace' },
+    { tool: myBountiesTool, group: 'marketplace' },
+    { tool: unsubscribeTool, group: 'marketplace' },
+    // Both — shared across core and marketplace
+    { tool: authTool, group: 'both' },
+    { tool: helpTool, group: 'both' },
+    { tool: feedbackTool, group: 'both' },
+];
+function parseServerMode() {
+    const serverArg = process.argv.find(a => a.startsWith('--server='));
+    if (!serverArg)
+        return 'all';
+    const mode = serverArg.split('=')[1];
+    if (mode === 'core' || mode === 'marketplace')
+        return mode;
+    console.error(`Unknown --server mode: "${mode}". Valid: core, marketplace. Defaulting to all.`);
+    return 'all';
+}
+const serverMode = parseServerMode();
+function isToolIncluded(entry) {
+    if (serverMode === 'all')
+        return true;
+    return entry.group === serverMode || entry.group === 'both';
+}
+const enabledTools = allTools.filter(isToolIncluded);
+// Build lookup map for call handler
+const toolMap = new Map();
+for (const entry of enabledTools) {
+    toolMap.set(entry.tool.name, entry.tool);
+}
+// ---------------------------------------------------------------------------
+// MCP Server
+// ---------------------------------------------------------------------------
 const server = new Server({
     name: 'librarian',
     version: '1.0.0',
@@ -19,67 +92,29 @@ const server = new Server({
 // List available tools
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
-        tools: [
-            {
-                name: briefTool.name,
-                description: briefTool.description,
-                inputSchema: briefTool.inputSchema,
-            },
-            {
-                name: recordTool.name,
-                description: recordTool.description,
-                inputSchema: recordTool.inputSchema,
-            },
-            {
-                name: adoptTool.name,
-                description: adoptTool.description,
-                inputSchema: adoptTool.inputSchema,
-            },
-            {
-                name: markHitTool.name,
-                description: markHitTool.description,
-                inputSchema: markHitTool.inputSchema,
-            },
-            {
-                name: importMemoriesTool.name,
-                description: importMemoriesTool.description,
-                inputSchema: importMemoriesTool.inputSchema,
-            },
-            {
-                name: rebuildIndexTool.name,
-                description: rebuildIndexTool.description,
-                inputSchema: rebuildIndexTool.inputSchema,
-            },
-        ],
+        tools: enabledTools.map(({ tool }) => {
+            const entry = {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+            };
+            if (tool.title)
+                entry.title = tool.title;
+            if (tool.outputSchema)
+                entry.outputSchema = tool.outputSchema;
+            return entry;
+        }),
     };
 });
 // Handle tool calls
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
-        let result;
-        switch (name) {
-            case 'brief':
-                result = await briefTool.handler(args);
-                break;
-            case 'record':
-                result = await recordTool.handler(args);
-                break;
-            case 'adopt':
-                result = await adoptTool.handler(args);
-                break;
-            case 'mark_hit':
-                result = await markHitTool.handler(args);
-                break;
-            case 'import_memories':
-                result = await importMemoriesTool.handler(args);
-                break;
-            case 'rebuild_index':
-                result = await rebuildIndexTool.handler(args);
-                break;
-            default:
-                throw new Error(`Unknown tool: ${name}`);
+        const tool = toolMap.get(name);
+        if (!tool) {
+            throw new Error(`Unknown tool: ${name}`);
         }
+        const result = await tool.handler(args);
         return {
             content: [
                 {
@@ -90,6 +125,19 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
     }
     catch (error) {
+        // Handle LibrarianError with error codes
+        if (error instanceof LibrarianError) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(error.toJSON()),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Handle generic errors
         const message = error instanceof Error ? error.message : String(error);
         return {
             content: [

package/dist/tools/adopt.d.ts

@@ -5,6 +5,7 @@ export interface AdoptResult {
 }
 export declare const adoptTool: {
     name: string;
+    title: string;
     description: string;
     inputSchema: {
         type: "object";

package/dist/tools/adopt.js

@@ -1,20 +1,29 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import matter from 'gray-matter';
-import { getLibraryPath, getImportedPath, getLocalPath } from '../library/storage.js';
+import { getLibraryPath, getImportedPath, getLocalPath, getPackagesPath } from '../library/storage.js';
 // ============================================================================
 // Tool Definition
 // ============================================================================
 export const adoptTool = {
     name: 'adopt',
-    description: `Make imported knowledge ours.
+    title: 'Adopt Imported Entry',
+    description: `Move an imported/packages entry to local library for editing.
 
-When an entry from an imported package proves useful, adopt it into our
-local library. It graduates from "their knowledge" to "our knowledge" -
-now we can edit and evolve it.
+USE THIS TOOL WHEN:
+- An imported entry is useful but needs customization
+- Want to evolve third-party knowledge with our learnings
+- Entry from packages/ or imported/ should become our own
+
+Copies to local/ where we can edit it. Original stays in place.
+
+TRIGGER PATTERNS:
+- Entry from brief() needs edits → adopt({ path: "..." })
+- "Make that entry ours" → adopt({ path: "...", title: "Our version" })
+- Want to customize purchased content → adopt({ path: "packages/..." })
 
 Examples:
-- adopt({ path: "imported/stripe-patterns/webhook-idempotency" })
+- adopt({ path: "packages/stripe-patterns/webhook-idempotency" })
 - adopt({ path: "imported/auth-patterns/token-refresh", title: "Our token refresh" })`,
     inputSchema: {
         type: 'object',
@@ -37,22 +46,40 @@ Examples:
         }
         const libraryPath = getLibraryPath();
         const importedPath = getImportedPath(libraryPath);
+        const packagesPath = getPackagesPath(libraryPath);
         const localPath = getLocalPath(libraryPath);
-        // Normalize path: strip "imported/" prefix if present, add .md if missing
+        // Normalize path: strip "imported/" or "packages/" prefix if present, add .md if missing
         let normalizedPath = entryPath;
         if (normalizedPath.startsWith('imported/')) {
             normalizedPath = normalizedPath.slice('imported/'.length);
         }
+        else if (normalizedPath.startsWith('packages/')) {
+            normalizedPath = normalizedPath.slice('packages/'.length);
+        }
         if (!normalizedPath.endsWith('.md')) {
             normalizedPath += '.md';
         }
-        const sourcePath = path.join(importedPath, normalizedPath);
-        // Check if source exists
+        // Try both imported/ and packages/ paths
+        let sourcePath = path.resolve(importedPath, normalizedPath);
+        // Prevent path traversal
+        if (!sourcePath.startsWith(path.resolve(importedPath)) && !sourcePath.startsWith(path.resolve(packagesPath))) {
+            throw new Error('Invalid path: must be within imported/ or packages/');
+        }
         try {
             await fs.access(sourcePath);
         }
         catch {
-            throw new Error(`Entry not found: ${entryPath}`);
+            // Try packages path (for library downloads)
+            sourcePath = path.resolve(packagesPath, normalizedPath);
+            if (!sourcePath.startsWith(path.resolve(packagesPath))) {
+                throw new Error('Invalid path: must be within imported/ or packages/');
+            }
+            try {
+                await fs.access(sourcePath);
+            }
+            catch {
+                throw new Error(`Entry not found: ${entryPath}`);
+            }
         }
         // Read source file
         const content = await fs.readFile(sourcePath, 'utf-8');

package/dist/tools/auth.d.ts

@@ -0,0 +1,69 @@
+export interface AuthData {
+    api_key: string;
+    user_email: string;
+    user_id: string;
+    created_at: string;
+    expires_at?: string;
+}
+export interface AuthResult {
+    authenticated: boolean;
+    user_email?: string;
+    user_id?: string;
+    message: string;
+    verification_url?: string;
+    user_code?: string;
+    expires_at?: string;
+    days_until_expiry?: number;
+}
+export declare const authTool: {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            action: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    outputSchema: {
+        type: "object";
+        properties: {
+            authenticated: {
+                type: string;
+            };
+            user_email: {
+                type: string;
+            };
+            user_id: {
+                type: string;
+            };
+            message: {
+                type: string;
+            };
+            verification_url: {
+                type: string;
+            };
+            user_code: {
+                type: string;
+            };
+            expires_at: {
+                type: string;
+            };
+            days_until_expiry: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+    handler(args: unknown): Promise<AuthResult>;
+};
+/**
+ * Load saved API key from auth file
+ * Used by other tools that need authenticated access
+ */
+export declare function loadApiKey(): Promise<string | null>;