@saccolabs/tars 1.37.0 → 1.37.1

package/extensions/search/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "tars-search",
+    "version": "1.0.0",
+    "description": "Web search and page fetching MCP server for Tars",
+    "type": "module",
+    "scripts": {
+        "build": "tsc",
+        "start": "node dist/server.js"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.26.0",
+        "duck-duck-scrape": "^2.2.5",
+        "linkedom": "^0.18.5",
+        "turndown": "^7.2.0"
+    },
+    "devDependencies": {
+        "@types/node": "^22.10.2",
+        "@types/turndown": "^5.0.5",
+        "typescript": "^5.7.2"
+    }
+}

package/extensions/search/src/search-helper.ts

@@ -0,0 +1,62 @@
+import { search } from 'duck-duck-scrape';
+import { parseHTML } from 'linkedom';
+import TurndownService from 'turndown';
+
+export interface SearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+
+/**
+ * Executes a DuckDuckGo search query and returns mapped search results.
+ */
+export async function performWebSearch(query: string, limit: number = 5): Promise<SearchResult[]> {
+    const response = await search(query);
+    const rawResults = response.results || [];
+    return rawResults.slice(0, limit).map((r: any) => ({
+        title: r.title || '',
+        url: r.url || '',
+        snippet: r.description || r.snippet || ''
+    }));
+}
+
+/**
+ * Fetches HTML from a URL, removes noise/boilerplate, and converts it to clean Markdown.
+ */
+export async function fetchWebPage(url: string, maxLength: number = 15000): Promise<string> {
+    const res = await fetch(url, {
+        headers: {
+            'User-Agent':
+                'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+        }
+    });
+
+    if (!res.ok) {
+        throw new Error(`Failed to fetch page: HTTP ${res.status} ${res.statusText}`);
+    }
+
+    const html = await res.text();
+    const { document } = parseHTML(html);
+
+    // Strip boilerplate, navigation, and script/style tags
+    const elementsToRemove = document.querySelectorAll(
+        'script, style, noscript, iframe, nav, header, footer, aside, svg, img, form, button'
+    );
+    elementsToRemove.forEach((el) => el.remove());
+
+    const bodyHtml = document.body ? document.body.innerHTML : document.documentElement.innerHTML;
+
+    const turndown = new TurndownService({
+        headingStyle: 'atx',
+        codeBlockStyle: 'fenced'
+    });
+
+    let markdown = turndown.turndown(bodyHtml).trim();
+
+    if (markdown.length > maxLength) {
+        markdown = markdown.substring(0, maxLength) + '\n\n...[Content truncated for brevity]...';
+    }
+
+    return markdown;
+}

package/extensions/search/src/server.ts

@@ -0,0 +1,127 @@
+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 { performWebSearch, fetchWebPage } from './search-helper.js';
+
+const server = new Server(
+    {
+        name: 'tars-search',
+        version: '1.0.0'
+    },
+    {
+        capabilities: {
+            tools: {}
+        }
+    }
+);
+
+/**
+ * Tool Definitions
+ */
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'web_search',
+                description:
+                    'Search the web using DuckDuckGo (free, keyless) and return a list of matches.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description:
+                                'The search query to execute (e.g. "latest version of Node.js")'
+                        },
+                        limit: {
+                            type: 'number',
+                            description:
+                                'Maximum number of results to return (default: 5, max: 10)',
+                            minimum: 1,
+                            maximum: 10
+                        }
+                    },
+                    required: ['query']
+                }
+            },
+            {
+                name: 'web_fetch',
+                description:
+                    'Fetch the text/Markdown content of a specific web URL, stripped of header/footer boilerplate.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        url: {
+                            type: 'string',
+                            description: 'The URL to fetch content from'
+                        }
+                    },
+                    required: ['url']
+                }
+            }
+        ]
+    };
+});
+
+/**
+ * Tool Handlers
+ */
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        switch (name) {
+            case 'web_search': {
+                const { query, limit = 5 } = args as { query: string; limit?: number };
+                if (!query) throw new Error('Query is required.');
+
+                const results = await performWebSearch(query, limit);
+
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(results, null, 2)
+                        }
+                    ]
+                };
+            }
+
+            case 'web_fetch': {
+                const { url } = args as { url: string };
+                if (!url) throw new Error('URL is required.');
+
+                const markdown = await fetchWebPage(url);
+
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: markdown
+                        }
+                    ]
+                };
+            }
+
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    } catch (error: any) {
+        return {
+            content: [{ type: 'text', text: `❌ Error: ${error.message}` }],
+            isError: true
+        };
+    }
+});
+
+// Start Server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('tars-search MCP server running on stdio');
+}
+
+main().catch((error) => {
+    console.error('Server error:', error);
+    process.exit(1);
+});

package/extensions/search/tars-extension.json

@@ -0,0 +1,11 @@
+{
+    "name": "tars-search",
+    "version": "1.0.0",
+    "description": "Web search and page fetching for Tars",
+    "mcpServers": {
+        "search": {
+            "command": "node",
+            "args": ["${extensionPath}/dist/server.js"]
+        }
+    }
+}

package/extensions/search/tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": ["src/**/*"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@saccolabs/tars",
-    "version": "1.37.0",
+    "version": "1.37.1",
     "description": "Tars — Your personal AI assistant",
     "publishConfig": {
         "access": "public"