@hasna/connectors 1.3.3 → 1.3.5

package/bin/index.js

@@ -3131,6 +3131,13 @@ var init_registry = __esm(() => {
       category: "Data & Analytics",
       tags: ["weather", "data"]
     },
+    {
+      name: "arxiv",
+      displayName: "arXiv",
+      description: "Research paper search and retrieval",
+      category: "Data & Analytics",
+      tags: ["research", "papers", "academic"]
+    },
     {
       name: "brandsight",
       displayName: "Brandsight",
@@ -11851,7 +11858,7 @@ import chalk2 from "chalk";
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.3.3",
+  version: "1.3.5",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {

package/bin/mcp.js

@@ -4570,6 +4570,7 @@ var require_limitLength = __commonJS((exports) => {
 var require_pattern = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var code_1 = require_code2();
+  var util_1 = require_util();
   var codegen_1 = require_codegen();
   var error2 = {
     message: ({ schemaCode }) => (0, codegen_1.str)`must match pattern "${schemaCode}"`,
@@ -4582,10 +4583,18 @@ var require_pattern = __commonJS((exports) => {
     $data: true,
     error: error2,
     code(cxt) {
-      const { data, $data, schema, schemaCode, it } = cxt;
+      const { gen, data, $data, schema, schemaCode, it } = cxt;
       const u = it.opts.unicodeRegExp ? "u" : "";
-      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-      cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      if ($data) {
+        const { regExp } = it.opts.code;
+        const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._)`new RegExp` : (0, util_1.useFunc)(gen, regExp);
+        const valid = gen.let("valid");
+        gen.try(() => gen.assign(valid, (0, codegen_1._)`${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+        cxt.fail$data((0, codegen_1._)`!${valid}`);
+      } else {
+        const regExp = (0, code_1.usePattern)(cxt, schema);
+        cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
+      }
     }
   };
   exports.default = def;
@@ -6278,7 +6287,7 @@ var require_formats = __commonJS((exports) => {
   }
   var TIME = /^(\d\d):(\d\d):(\d\d(?:\.\d+)?)(z|([+-])(\d\d)(?::?(\d\d))?)?$/i;
   function getTime(strictTimeZone) {
-    return function time3(str) {
+    return function time(str) {
       const matches = TIME.exec(str);
       if (!matches)
         return false;
@@ -19001,6 +19010,62 @@ class ExperimentalServerTasks {
   requestStream(request, resultSchema, options) {
     return this._server.requestStream(request, resultSchema, options);
   }
+  createMessageStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
+      throw new Error("Client does not support sampling tools capability.");
+    }
+    if (params.messages.length > 0) {
+      const lastMessage = params.messages[params.messages.length - 1];
+      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
+      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+      if (hasToolResults) {
+        if (lastContent.some((c) => c.type !== "tool_result")) {
+          throw new Error("The last message must contain only tool_result content if any is present");
+        }
+        if (!hasPreviousToolUse) {
+          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+        }
+      }
+      if (hasPreviousToolUse) {
+        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
+          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+        }
+      }
+    }
+    return this.requestStream({
+      method: "sampling/createMessage",
+      params
+    }, CreateMessageResultSchema, options);
+  }
+  elicitInputStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    const mode = params.mode ?? "form";
+    switch (mode) {
+      case "url": {
+        if (!clientCapabilities?.elicitation?.url) {
+          throw new Error("Client does not support url elicitation.");
+        }
+        break;
+      }
+      case "form": {
+        if (!clientCapabilities?.elicitation?.form) {
+          throw new Error("Client does not support form elicitation.");
+        }
+        break;
+      }
+    }
+    const normalizedParams = mode === "form" && params.mode === undefined ? { ...params, mode: "form" } : params;
+    return this.requestStream({
+      method: "elicitation/create",
+      params: normalizedParams
+    }, ElicitResultSchema, options);
+  }
   async getTask(taskId, options) {
     return this._server.getTask({ taskId }, options);
   }
@@ -20777,6 +20842,13 @@ var CONNECTORS = [
     category: "Data & Analytics",
     tags: ["weather", "data"]
   },
+  {
+    name: "arxiv",
+    displayName: "arXiv",
+    description: "Research paper search and retrieval",
+    category: "Data & Analytics",
+    tags: ["research", "papers", "academic"]
+  },
   {
     name: "brandsight",
     displayName: "Brandsight",
@@ -27017,7 +27089,7 @@ init_strip();
 // package.json
 var package_default = {
   name: "@hasna/connectors",
-  version: "1.3.3",
+  version: "1.3.5",
   description: "Open source connector library - Install API connectors with a single command",
   type: "module",
   bin: {
@@ -27723,6 +27795,32 @@ server.registerTool("get_rate_budget", {
   const result = getRateBudget(agent_id, connector, limit);
   return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
 });
+var _agentReg = new Map;
+server.tool("register_agent", "Register this agent session. Returns agent_id for use in heartbeat/set_focus.", { name: exports_external.string(), session_id: exports_external.string().optional() }, async (a) => {
+  const existing = [..._agentReg.values()].find((x) => x.name === a.name);
+  if (existing) {
+    existing.last_seen_at = new Date().toISOString();
+    return { content: [{ type: "text", text: JSON.stringify(existing) }] };
+  }
+  const id = Math.random().toString(36).slice(2, 10);
+  const ag = { id, name: a.name, last_seen_at: new Date().toISOString() };
+  _agentReg.set(id, ag);
+  return { content: [{ type: "text", text: JSON.stringify(ag) }] };
+});
+server.tool("heartbeat", "Update last_seen_at to signal agent is active.", { agent_id: exports_external.string() }, async (a) => {
+  const ag = _agentReg.get(a.agent_id);
+  if (!ag)
+    return { content: [{ type: "text", text: `Agent not found: ${a.agent_id}` }], isError: true };
+  ag.last_seen_at = new Date().toISOString();
+  return { content: [{ type: "text", text: `\u2665 ${ag.name} \u2014 active` }] };
+});
+server.tool("set_focus", "Set active project context for this agent session.", { agent_id: exports_external.string(), project_id: exports_external.string().optional() }, async (a) => {
+  const ag = _agentReg.get(a.agent_id);
+  if (!ag)
+    return { content: [{ type: "text", text: `Agent not found: ${a.agent_id}` }], isError: true };
+  ag.project_id = a.project_id;
+  return { content: [{ type: "text", text: a.project_id ? `Focus: ${a.project_id}` : "Focus cleared" }] };
+});
 async function main() {
   const transport = new StdioServerTransport;
   await server.connect(transport);

package/bin/serve.js

@@ -1,6 +1,21 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -1177,6 +1192,13 @@ var CONNECTORS = [
     category: "Data & Analytics",
     tags: ["weather", "data"]
   },
+  {
+    name: "arxiv",
+    displayName: "arXiv",
+    description: "Research paper search and retrieval",
+    category: "Data & Analytics",
+    tags: ["research", "papers", "academic"]
+  },
   {
     name: "brandsight",
     displayName: "Brandsight",

package/connectors/connect-arxiv/CLAUDE.md

@@ -0,0 +1,80 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code when working with this repository.
+
+## Project Overview
+
+arXiv research paper search and retrieval connector CLI - Search papers, get metadata, list recent papers, search by author, download PDFs
+
+## Build & Run Commands
+
+```bash
+# Install dependencies
+bun install
+
+# Run CLI in development
+bun run dev
+
+# Build for distribution
+bun run build
+
+# Type check
+bun run typecheck
+```
+
+## Code Style
+
+- TypeScript with strict mode
+- ESM modules (`type: module`)
+- Async/await for all async operations
+- Minimal dependencies: commander, chalk
+- Type annotations required everywhere
+
+## Project Structure
+
+```
+src/
+├── api/           # API client modules
+│   ├── client.ts  # HTTP client (XML parsing)
+│   └── index.ts   # Main connector class
+├── cli/
+│   └── index.ts   # CLI commands
+├── types/
+│   └── index.ts   # TypeScript types
+├── utils/
+│   ├── config.ts  # Configuration
+│   └── output.ts  # CLI output formatting
+└── index.ts       # Library exports
+```
+
+## API Notes
+
+arXiv API is free — no API key or authentication required.
+- Base URL: `http://export.arxiv.org/api/query`
+- Returns Atom XML (parsed internally)
+- Rate limit: Be respectful — no more than 1 request per 3 seconds recommended
+- Categories: cs.AI, cs.LG, cs.CL, math.CO, physics.hep-th, etc.
+
+## Authentication
+
+None required. The arXiv API is free and open.
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `ARXIV_CATEGORY` | Default category filter |
+| `ARXIV_MAX_RESULTS` | Default max results (default: 10) |
+| `ARXIV_OUTPUT_DIR` | Default PDF download directory |
+
+## Data Storage
+
+```
+~/.connectors/connect-arxiv/
+└── config.json    # User preferences (category, max results, output dir)
+```
+
+## Dependencies
+
+- commander: CLI framework
+- chalk: Terminal styling

package/connectors/connect-arxiv/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@hasna/connect-arxiv",
+  "version": "0.1.0",
+  "description": "arXiv research paper search and retrieval connector CLI",
+  "type": "module",
+  "bin": { "connect-arxiv": "./bin/index.js" },
+  "exports": { ".": { "import": "./dist/index.js", "types": "./dist/index.d.ts" } },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && bun build ./src/cli/index.ts --outdir ./bin --target bun",
+    "dev": "bun run ./src/cli/index.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": ["arxiv", "research", "papers", "academic", "search", "api", "connector", "cli", "typescript", "bun", "hasna"],
+  "author": "Hasna",
+  "license": "Apache-2.0",
+  "devDependencies": { "@types/bun": "latest", "typescript": "^5" },
+  "dependencies": { "commander": "^12.1.0", "chalk": "^5.3.0" },
+  "engines": { "bun": ">=1.0.0" },
+  "repository": { "type": "git", "url": "git+https://github.com/hasna/connectors.git" }
+}

package/connectors/connect-arxiv/src/api/client.ts

@@ -0,0 +1,203 @@
+import type { ArxivPaper, SearchResult, SearchOptions } from '../types';
+import { ArxivApiError } from '../types';
+
+const BASE_URL = 'http://export.arxiv.org/api/query';
+
+export class ArxivClient {
+  /**
+   * Execute a search query against the arXiv API
+   */
+  async search(options: SearchOptions): Promise<SearchResult> {
+    const params = new URLSearchParams();
+
+    // Build search query
+    let searchQuery = options.query;
+    if (options.category) {
+      searchQuery = `cat:${options.category} AND ${searchQuery}`;
+    }
+    params.set('search_query', searchQuery);
+    params.set('start', String(options.start || 0));
+    params.set('max_results', String(options.maxResults || 10));
+
+    if (options.sortBy) {
+      params.set('sortBy', options.sortBy);
+    }
+    if (options.sortOrder) {
+      params.set('sortOrder', options.sortOrder);
+    }
+
+    const url = `${BASE_URL}?${params.toString()}`;
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new ArxivApiError(`arXiv API error: ${response.statusText}`, response.status);
+    }
+
+    const xml = await response.text();
+    return this.parseSearchResult(xml);
+  }
+
+  /**
+   * Get a paper by its arXiv ID
+   */
+  async get(arxivId: string): Promise<ArxivPaper> {
+    // Normalize ID (remove version suffix for query, keep for display)
+    const cleanId = arxivId.replace(/^arxiv:/i, '');
+    const params = new URLSearchParams({
+      id_list: cleanId,
+      max_results: '1',
+    });
+
+    const url = `${BASE_URL}?${params.toString()}`;
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new ArxivApiError(`arXiv API error: ${response.statusText}`, response.status);
+    }
+
+    const xml = await response.text();
+    const result = this.parseSearchResult(xml);
+
+    if (result.papers.length === 0) {
+      throw new ArxivApiError(`Paper not found: ${arxivId}`);
+    }
+
+    return result.papers[0];
+  }
+
+  /**
+   * List recent papers in a category
+   */
+  async listRecent(category: string, options?: { maxResults?: number; start?: number }): Promise<SearchResult> {
+    return this.search({
+      query: `cat:${category}`,
+      maxResults: options?.maxResults || 20,
+      start: options?.start || 0,
+      sortBy: 'submittedDate',
+      sortOrder: 'descending',
+    });
+  }
+
+  /**
+   * Search papers by author name
+   */
+  async searchAuthors(authorName: string, options?: { maxResults?: number; start?: number }): Promise<SearchResult> {
+    return this.search({
+      query: `au:"${authorName}"`,
+      maxResults: options?.maxResults || 10,
+      start: options?.start || 0,
+      sortBy: 'submittedDate',
+      sortOrder: 'descending',
+    });
+  }
+
+  /**
+   * Download paper PDF to local path
+   */
+  async downloadPdf(arxivId: string, outputPath: string): Promise<string> {
+    const cleanId = arxivId.replace(/^arxiv:/i, '');
+    const pdfUrl = `https://arxiv.org/pdf/${cleanId}.pdf`;
+
+    const response = await fetch(pdfUrl);
+    if (!response.ok) {
+      throw new ArxivApiError(`Failed to download PDF: ${response.statusText}`, response.status);
+    }
+
+    const buffer = await response.arrayBuffer();
+    const { writeFileSync } = await import('fs');
+    writeFileSync(outputPath, Buffer.from(buffer));
+
+    return outputPath;
+  }
+
+  /**
+   * Parse Atom XML response into SearchResult
+   */
+  private parseSearchResult(xml: string): SearchResult {
+    const totalResults = parseInt(this.extractTag(xml, 'opensearch:totalResults') || '0', 10);
+    const startIndex = parseInt(this.extractTag(xml, 'opensearch:startIndex') || '0', 10);
+    const itemsPerPage = parseInt(this.extractTag(xml, 'opensearch:itemsPerPage') || '0', 10);
+
+    const papers: ArxivPaper[] = [];
+    const entries = xml.split('<entry>').slice(1);
+
+    for (const entry of entries) {
+      const entryXml = entry.split('</entry>')[0];
+      const paper = this.parseEntry(entryXml);
+      if (paper) {
+        papers.push(paper);
+      }
+    }
+
+    return { papers, totalResults, startIndex, itemsPerPage };
+  }
+
+  /**
+   * Parse a single Atom entry into an ArxivPaper
+   */
+  private parseEntry(xml: string): ArxivPaper | null {
+    const fullId = this.extractTag(xml, 'id') || '';
+    // Extract arXiv ID from URL: http://arxiv.org/abs/2301.12345v1
+    const idMatch = fullId.match(/arxiv\.org\/abs\/(.+)/);
+    if (!idMatch) return null;
+
+    const id = idMatch[1].replace(/v\d+$/, ''); // Remove version suffix
+
+    const title = (this.extractTag(xml, 'title') || '').replace(/\s+/g, ' ').trim();
+    const abstract = (this.extractTag(xml, 'summary') || '').replace(/\s+/g, ' ').trim();
+    const published = this.extractTag(xml, 'published') || '';
+    const updated = this.extractTag(xml, 'updated') || '';
+    const doi = this.extractTag(xml, 'arxiv:doi') || undefined;
+    const journalRef = this.extractTag(xml, 'arxiv:journal_ref') || undefined;
+    const comment = this.extractTag(xml, 'arxiv:comment') || undefined;
+
+    // Extract authors
+    const authors: string[] = [];
+    const authorMatches = xml.matchAll(/<author>\s*<name>([^<]+)<\/name>/g);
+    for (const match of authorMatches) {
+      authors.push(match[1].trim());
+    }
+
+    // Extract categories
+    const categories: string[] = [];
+    const catMatches = xml.matchAll(/category[^>]*term="([^"]+)"/g);
+    for (const match of catMatches) {
+      categories.push(match[1]);
+    }
+
+    // Extract primary category
+    const primaryCatMatch = xml.match(/arxiv:primary_category[^>]*term="([^"]+)"/);
+    const primaryCategory = primaryCatMatch ? primaryCatMatch[1] : categories[0] || '';
+
+    // Extract PDF link
+    const pdfMatch = xml.match(/<link[^>]*title="pdf"[^>]*href="([^"]+)"/);
+    const pdfUrl = pdfMatch ? pdfMatch[1] : `https://arxiv.org/pdf/${id}.pdf`;
+
+    const absUrl = `https://arxiv.org/abs/${id}`;
+
+    return {
+      id,
+      title,
+      authors,
+      abstract,
+      categories,
+      primaryCategory,
+      published,
+      updated,
+      pdfUrl,
+      absUrl,
+      doi,
+      journalRef,
+      comment,
+    };
+  }
+
+  /**
+   * Extract text content of an XML tag
+   */
+  private extractTag(xml: string, tag: string): string | null {
+    const escapedTag = tag.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const match = xml.match(new RegExp(`<${escapedTag}[^>]*>([\\s\\S]*?)<\\/${escapedTag}>`));
+    return match ? match[1].trim() : null;
+  }
+}

package/connectors/connect-arxiv/src/api/index.ts

@@ -0,0 +1,47 @@
+import { ArxivClient } from './client';
+
+export class Arxiv {
+  public readonly client: ArxivClient;
+
+  constructor() {
+    this.client = new ArxivClient();
+  }
+
+  /**
+   * Search papers by query
+   */
+  get search() {
+    return this.client.search.bind(this.client);
+  }
+
+  /**
+   * Get paper by ID
+   */
+  get get() {
+    return this.client.get.bind(this.client);
+  }
+
+  /**
+   * List recent papers in a category
+   */
+  get listRecent() {
+    return this.client.listRecent.bind(this.client);
+  }
+
+  /**
+   * Search papers by author
+   */
+  get searchAuthors() {
+    return this.client.searchAuthors.bind(this.client);
+  }
+
+  /**
+   * Download paper PDF
+   */
+  get downloadPdf() {
+    return this.client.downloadPdf.bind(this.client);
+  }
+}
+
+export { ArxivClient } from './client';
+export { Arxiv as Connector };