@jackwener/opencli 1.0.6 → 1.1.1

package/dist/clis/antigravity/serve.js

@@ -52,68 +52,254 @@ function jsonResponse(res, status, data) {
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
+// ─── DOM helpers ─────────────────────────────────────────────────────
+/**
+ * Click the 'New Conversation' button to reset context.
+ */
+async function startNewConversation(page) {
+    await page.evaluate(`
+    (() => {
+      const btn = document.querySelector('[data-tooltip-id="new-conversation-tooltip"]');
+      if (btn) btn.click();
+    })()
+  `);
+    await sleep(1000); // Give UI time to clear
+}
+/**
+ * Switch the active model in Antigravity UI.
+ */
+async function switchModel(page, anthropicModelId) {
+    // Map standard model IDs to Antigravity UI names based on actual UI
+    let targetName = 'claude sonnet 4.6'; // Default fallback
+    const id = anthropicModelId.toLowerCase();
+    if (id.includes('sonnet')) {
+        targetName = 'claude sonnet 4.6';
+    }
+    else if (id.includes('opus')) {
+        targetName = 'claude opus 4.6';
+    }
+    else if (id.includes('gemini') && id.includes('pro')) {
+        targetName = 'gemini 3.1 pro (high)';
+    }
+    else if (id.includes('gemini') && id.includes('flash')) {
+        targetName = 'gemini 3 flash';
+    }
+    else if (id.includes('gpt')) {
+        targetName = 'gpt-oss 120b';
+    }
+    try {
+        await page.evaluate(`
+      async () => {
+        const targetModelName = ${JSON.stringify(targetName)};
+        const trigger = document.querySelector('div[aria-haspopup="dialog"] > div[tabindex="0"]');
+        if (!trigger) return; // Silent fail if UI changed
+        
+        // Open dropdown only if not already selected
+        if (trigger.innerText.toLowerCase().includes(targetModelName)) return;
+        
+        trigger.click();
+        await new Promise(r => setTimeout(r, 200));
+        
+        const spans = Array.from(document.querySelectorAll('[role="dialog"] span'));
+        const target = spans.find(s => s.innerText.toLowerCase().includes(targetModelName));
+        if (target) {
+          const optionNode = target.closest('.cursor-pointer') || target;
+          optionNode.click();
+        } else {
+          // Close if not found
+          trigger.click(); 
+        }
+      }
+    `);
+        await sleep(500); // Wait for switch
+    }
+    catch (err) {
+        console.error(`[serve] Warning: Could not switch to model ${targetName}:`, err);
+    }
+}
+/**
+ * Check if the Antigravity UI is currently generating a response
+ * by looking for Stop/Cancel buttons or loading indicators.
+ */
+async function isGenerating(page) {
+    const result = await page.evaluate(`
+    (() => {
+      // Look for a cancel/stop button in the UI
+      const cancelBtn = document.querySelector('button[aria-label*="cancel" i], button[aria-label*="stop" i], button[title*="cancel" i], button[title*="stop" i]');
+      return !!cancelBtn;
+    })()
+  `);
+    return Boolean(result);
+}
+/**
+ * Walk from the scroll container and find the deepest element that
+ * has multiple non-empty children (our message container).
+ */
+function findMessageContainer(root, depth = 0) {
+    if (!root || depth > 12)
+        return null;
+    const nonEmpty = Array.from(root.children).filter(c => c.innerText?.trim().length > 5);
+    if (nonEmpty.length >= 2)
+        return root;
+    if (nonEmpty.length === 1)
+        return findMessageContainer(nonEmpty[0], depth + 1);
+    return root;
+}
 // ─── Antigravity CDP Operations ──────────────────────────────────────
+/**
+ * Get the full chat text for change-detection polling.
+ */
 async function getConversationText(page) {
     const text = await page.evaluate(`
     (() => {
       const container = document.getElementById('conversation');
-      return container ? container.innerText : '';
+      if (!container) return '';
+      // Read only the first child div (actual chat content),
+      // skipping UI chrome like file change panels, model selectors, etc.
+      const chatContent = container.children[0];
+      return chatContent ? chatContent.innerText : container.innerText;
     })()
   `);
     return String(text ?? '');
 }
-async function sendMessage(page, message) {
-    await page.evaluate(`
-    (async () => {
+/**
+ * Get the text of the last assistant reply by navigating to the message container
+ * and extracting the last non-empty message block.
+ */
+async function getLastAssistantReply(page, userText) {
+    const text = await page.evaluate(`
+    (() => {
+      const conv = document.getElementById('conversation')?.children[0];
+      const scroll = conv?.querySelector('.overflow-y-auto');
+      
+      // Walk down until we find a container with multiple message siblings
+      function findMsgContainer(el, depth) {
+        if (!el || depth > 12) return null;
+        const nonEmpty = Array.from(el.children).filter(c => c.innerText && c.innerText.trim().length > 5);
+        if (nonEmpty.length >= 2) return el;
+        if (nonEmpty.length === 1) return findMsgContainer(nonEmpty[0], depth + 1);
+        return null;
+      }
+      
+      const container = findMsgContainer(scroll || conv, 0);
+      if (!container) return '';
+      
+      // Get all non-empty children (skip trailing empty UI divs)
+      const msgs = Array.from(container.children).filter(
+        c => c.innerText && c.innerText.trim().length > 5
+      );
+      
+      if (msgs.length === 0) return '';
+      
+      // The last element is the last assistant reply
+      const last = msgs[msgs.length - 1];
+      return last.innerText || '';
+    })()
+  `);
+    let reply = String(text ?? '').trim();
+    // Strip echoed user message from the top (Antigravity sometimes includes it)
+    if (userText && reply.startsWith(userText)) {
+        reply = reply.slice(userText.length).trim();
+    }
+    // Strip thinking block: "Thought for Xs\n..." at the start
+    reply = reply.replace(/^Thought for[^\n]*\n+/i, '').trim();
+    // Strip "Copy" button text at the end
+    reply = reply.replace(/\s*\bCopy\b\s*$/m, '').trim();
+    // De-duplicate trailing repeated content (e.g., "OK\n\nOK" → "OK")
+    const half = Math.floor(reply.length / 2);
+    const firstHalf = reply.slice(0, half).trim();
+    const secondHalf = reply.slice(half).trim();
+    if (firstHalf && firstHalf === secondHalf) {
+        reply = firstHalf;
+    }
+    return reply;
+}
+async function sendMessage(page, message, bridge) {
+    if (!bridge) {
+        // Fallback: use JS-based approach
+        await page.evaluate(`
+      (() => {
+        const container = document.getElementById('antigravity.agentSidePanelInputBox');
+        const editor = container?.querySelector('[data-lexical-editor="true"]');
+        if (!editor) throw new Error('Could not find input box');
+        editor.focus();
+        document.execCommand('insertText', false, ${JSON.stringify(message)});
+      })()
+    `);
+        await sleep(500);
+        await page.pressKey('Enter');
+        return;
+    }
+    // Get the bounding box of the Lexical editor for a physical mouse click
+    const rect = await page.evaluate(`
+    (() => {
       const container = document.getElementById('antigravity.agentSidePanelInputBox');
       if (!container) throw new Error('Could not find antigravity.agentSidePanelInputBox');
       const editor = container.querySelector('[data-lexical-editor="true"]');
       if (!editor) throw new Error('Could not find Antigravity input box');
-      
-      editor.focus();
-      document.execCommand('insertText', false, ${JSON.stringify(message)});
+      const r = editor.getBoundingClientRect();
+      return JSON.stringify({ x: r.left + r.width / 2, y: r.top + r.height / 2 });
     })()
   `);
-    await sleep(500);
-    await page.pressKey('Enter');
+    const { x, y } = JSON.parse(String(rect));
+    // Physical mouse click to give the element real browser focus
+    await bridge.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
+    await sleep(50);
+    await bridge.send('Input.dispatchMouseEvent', { type: 'mouseReleased', x, y, button: 'left', clickCount: 1 });
+    await sleep(200);
+    // Inject text at the CDP level (no deprecated execCommand)
+    await bridge.send('Input.insertText', { text: message });
+    await sleep(300);
+    // Send Enter via native CDP key event
+    await bridge.send('Input.dispatchKeyEvent', { type: 'keyDown', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 });
+    await sleep(50);
+    await bridge.send('Input.dispatchKeyEvent', { type: 'keyUp', key: 'Enter', code: 'Enter', windowsVirtualKeyCode: 13, nativeVirtualKeyCode: 13 });
 }
 async function waitForReply(page, beforeText, opts = {}) {
     const timeout = opts.timeout ?? 120_000; // 2 minutes max
     const pollInterval = opts.pollInterval ?? 500; // 500ms polling
-    const stableThreshold = opts.stableThreshold ?? 6; // 6 × 500ms = 3s stable
     const deadline = Date.now() + timeout;
+    // Wait a bit to ensure the UI transitions to "generating" state after we hit Enter
+    await sleep(1000);
+    let hasStartedGenerating = false;
     let lastText = beforeText;
     let stableCount = 0;
-    // Wait a bit for the model to start generating
-    await sleep(1000);
+    const stableThreshold = 4; // 4 * 500ms = 2s of stability fallback
     while (Date.now() < deadline) {
-        const current = await getConversationText(page);
-        if (current.length > beforeText.length) {
-            // New content appeared
-            if (current === lastText) {
-                stableCount++;
-                if (stableCount >= stableThreshold) {
-                    // Text has been stable — reply is complete
-                    return current.slice(beforeText.length).trim();
-                }
+        const generating = await isGenerating(page);
+        const currentText = await getConversationText(page);
+        const textChanged = currentText !== beforeText && currentText.length > 0;
+        if (generating) {
+            hasStartedGenerating = true;
+            stableCount = 0; // Reset stability while generating
+        }
+        else {
+            if (hasStartedGenerating) {
+                // It actively generated and now it stopped -> DONE
+                // Provide a small buffer to let React render the final message fully
+                await sleep(500);
+                return;
             }
-            else {
-                // Still generating
-                stableCount = 0;
-                lastText = current;
+            // Fallback: If it never showed "Generating/Cancel", but text changed and is stable
+            if (textChanged) {
+                if (currentText === lastText) {
+                    stableCount++;
+                    if (stableCount >= stableThreshold) {
+                        return; // Text has been stable for 2 seconds -> DONE
+                    }
+                }
+                else {
+                    stableCount = 0;
+                    lastText = currentText;
+                }
             }
         }
         await sleep(pollInterval);
     }
-    // Timeout — return whatever we have
-    const finalText = await getConversationText(page);
-    if (finalText.length > beforeText.length) {
-        return finalText.slice(beforeText.length).trim();
-    }
     throw new Error('Timeout waiting for Antigravity reply');
 }
 // ─── Request Handlers ────────────────────────────────────────────────
-async function handleMessages(body, page) {
+async function handleMessages(body, page, bridge) {
     // Extract the last user message
     const userMessages = body.messages.filter(m => m.role === 'user');
     if (userMessages.length === 0) {
@@ -124,14 +310,25 @@ async function handleMessages(body, page) {
     if (!userText.trim()) {
         throw new Error('Empty user message');
     }
+    // Optimization 1: New conversation if this is the first message in the session
+    if (body.messages.length === 1) {
+        console.error(`[serve] New session detected (1 message). Starting new conversation in UI.`);
+        await startNewConversation(page);
+    }
+    // Optimization 3: Switch model if requested
+    if (body.model) {
+        await switchModel(page, body.model);
+    }
     // Get conversation state before sending
     const beforeText = await getConversationText(page);
     // Send the message
     console.error(`[serve] Sending: "${userText.slice(0, 80)}${userText.length > 80 ? '...' : ''}"`);
-    await sendMessage(page, userText);
-    // Poll for reply
+    await sendMessage(page, userText, bridge);
+    // Poll for reply (change detection)
     console.error('[serve] Waiting for reply...');
-    const replyText = await waitForReply(page, beforeText);
+    await waitForReply(page, beforeText);
+    // Extract the actual reply text precisely from the DOM
+    const replyText = await getLastAssistantReply(page, userText);
     console.error(`[serve] Got reply: "${replyText.slice(0, 80)}${replyText.length > 80 ? '...' : ''}"`);
     return {
         id: generateMsgId(),
@@ -150,15 +347,65 @@ async function handleMessages(body, page) {
 // ─── Server ──────────────────────────────────────────────────────────
 export async function startServe(opts = {}) {
     const port = opts.port ?? 8082;
-    // Establish persistent CDP connection
-    console.error('[serve] Connecting to Antigravity via CDP...');
-    const cdp = new CDPBridge();
-    const page = await cdp.connect({ timeout: 15_000 });
-    console.error('[serve] CDP connected successfully.');
-    // Verify we can read conversation
-    const testText = await getConversationText(page);
-    console.error(`[serve] Conversation element found (${testText.length} chars).`);
+    // Lazy CDP connection — connect when first request comes in
+    let cdp = null;
+    let page = null;
     let requestInFlight = false;
+    async function ensureConnected() {
+        if (page) {
+            try {
+                await page.evaluate('1+1');
+                return page;
+            }
+            catch {
+                console.error('[serve] CDP connection lost, reconnecting...');
+                cdp?.close().catch(() => { });
+                cdp = null;
+                page = null;
+            }
+        }
+        const endpoint = process.env.OPENCLI_CDP_ENDPOINT;
+        if (!endpoint) {
+            throw new Error('OPENCLI_CDP_ENDPOINT is not set.\n' +
+                'Usage: OPENCLI_CDP_ENDPOINT=http://127.0.0.1:9224 opencli antigravity serve');
+        }
+        // Note: Antigravity chat panel lives inside editor windows, not in Launchpad.
+        // If multiple editor windows are open, set OPENCLI_CDP_TARGET to the window title.
+        if (process.env.OPENCLI_CDP_TARGET) {
+            console.error(`[serve] Using OPENCLI_CDP_TARGET=${process.env.OPENCLI_CDP_TARGET}`);
+        }
+        // List available targets for debugging
+        try {
+            const res = await fetch(`${endpoint.replace(/\/$/, '')}/json`);
+            const targets = await res.json();
+            const pages = targets.filter(t => t.type === 'page');
+            console.error(`[serve] Available targets: ${pages.map(t => `"${t.title}"`).join(', ')}`);
+        }
+        catch { /* ignore */ }
+        console.error(`[serve] Connecting via CDP (target pattern: "${process.env.OPENCLI_CDP_TARGET}")...`);
+        cdp = new CDPBridge();
+        try {
+            page = await cdp.connect({ timeout: 15_000 });
+        }
+        catch (err) {
+            cdp = null;
+            const isRefused = err?.cause?.code === 'ECONNREFUSED' || err?.message?.includes('ECONNREFUSED');
+            throw new Error(isRefused
+                ? `Cannot connect to Antigravity at ${endpoint}.\n` +
+                    '  1. Make sure Antigravity is running\n' +
+                    '  2. Launch with: --remote-debugging-port=9224'
+                : `CDP connection failed: ${err.message}`);
+        }
+        console.error('[serve] ✅ CDP connected.');
+        // Quick verification
+        const hasUI = await page.evaluate(`
+      (() => !!document.getElementById('conversation') || !!document.getElementById('antigravity.agentSidePanelInputBox'))()
+    `);
+        if (!hasUI) {
+            console.error('[serve] ⚠️  Warning: chat UI elements not found in this target. Try setting OPENCLI_CDP_TARGET to the correct window title.');
+        }
+        return page;
+    }
     const server = createServer(async (req, res) => {
         // CORS preflight
         if (req.method === 'OPTIONS') {
@@ -204,7 +451,6 @@ export async function startServe(opts = {}) {
                     const rawBody = await readBody(req);
                     const body = JSON.parse(rawBody);
                     if (body.stream) {
-                        // We don't support streaming — return error
                         jsonResponse(res, 400, {
                             type: 'error',
                             error: {
@@ -214,7 +460,9 @@ export async function startServe(opts = {}) {
                         });
                         return;
                     }
-                    const response = await handleMessages(body, page);
+                    // Lazy connect on first request
+                    const activePage = await ensureConnected();
+                    const response = await handleMessages(body, activePage, cdp ?? undefined);
                     jsonResponse(res, 200, response);
                 }
                 finally {
@@ -224,7 +472,7 @@ export async function startServe(opts = {}) {
             }
             // Health check
             if (req.method === 'GET' && (pathname === '/' || pathname === '/health')) {
-                jsonResponse(res, 200, { ok: true, status: 'connected' });
+                jsonResponse(res, 200, { ok: true, cdpConnected: page !== null });
                 return;
             }
             jsonResponse(res, 404, {
@@ -233,7 +481,7 @@ export async function startServe(opts = {}) {
             });
         }
         catch (err) {
-            console.error('[serve] Error:', err);
+            console.error('[serve] Error:', err instanceof Error ? err.message : err);
             jsonResponse(res, 500, {
                 type: 'error',
                 error: {
@@ -246,13 +494,14 @@ export async function startServe(opts = {}) {
     server.listen(port, '127.0.0.1', () => {
         console.error(`\n[serve] ✅ Antigravity API proxy running at http://127.0.0.1:${port}`);
         console.error(`[serve] Compatible with Anthropic /v1/messages API`);
+        console.error(`[serve] CDP connection will be established on first request.`);
         console.error(`\n[serve] Usage with Claude Code:`);
         console.error(`  ANTHROPIC_BASE_URL=http://localhost:${port} claude\n`);
     });
     // Graceful shutdown
     const shutdown = () => {
         console.error('\n[serve] Shutting down...');
-        cdp.close().catch(() => { });
+        cdp?.close().catch(() => { });
         server.close();
         process.exit(0);
     };

package/dist/clis/apple-podcasts/commands.test.d.ts

@@ -0,0 +1,2 @@
+import './search.js';
+import './top.js';

package/dist/clis/apple-podcasts/commands.test.js

@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './search.js';
+import './top.js';
+describe('apple-podcasts search command', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('uses the positional query argument for the iTunes search request', async () => {
+        const cmd = getRegistry().get('apple-podcasts/search');
+        expect(cmd?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                results: [
+                    {
+                        collectionId: 42,
+                        collectionName: 'Machine Learning Guide',
+                        artistName: 'OpenCLI',
+                        trackCount: 12,
+                        primaryGenreName: 'Technology',
+                    },
+                ],
+            }),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await cmd.func(null, {
+            query: 'machine learning',
+            keyword: 'sports',
+            limit: 5,
+        });
+        expect(fetchMock).toHaveBeenCalledWith('https://itunes.apple.com/search?term=machine%20learning&media=podcast&limit=5');
+        expect(result).toEqual([
+            {
+                id: 42,
+                title: 'Machine Learning Guide',
+                author: 'OpenCLI',
+                episodes: 12,
+                genre: 'Technology',
+            },
+        ]);
+    });
+});
+describe('apple-podcasts top command', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('uses the canonical Apple charts host and maps ranked results', async () => {
+        const cmd = getRegistry().get('apple-podcasts/top');
+        expect(cmd?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                feed: {
+                    results: [
+                        { id: '100', name: 'Top Show', artistName: 'Host A' },
+                        { id: '101', name: 'Second Show', artistName: 'Host B' },
+                    ],
+                },
+            }),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await cmd.func(null, { country: 'US', limit: 2 });
+        expect(fetchMock).toHaveBeenCalledWith('https://rss.marketingtools.apple.com/api/v2/us/podcasts/top/2/podcasts.json');
+        expect(result).toEqual([
+            { rank: 1, title: 'Top Show', author: 'Host A', id: '100' },
+            { rank: 2, title: 'Second Show', author: 'Host B', id: '101' },
+        ]);
+    });
+    it('normalizes network failures into CliError output', async () => {
+        const cmd = getRegistry().get('apple-podcasts/top');
+        expect(cmd?.func).toBeTypeOf('function');
+        vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('socket hang up')));
+        await expect(cmd.func(null, { country: 'us', limit: 3 })).rejects.toThrow('Unable to reach Apple Podcasts charts for US');
+    });
+});

package/dist/clis/apple-podcasts/search.js

@@ -8,12 +8,12 @@ cli({
     strategy: Strategy.PUBLIC,
     browser: false,
     args: [
-        { name: 'keyword', positional: true, required: true, help: 'Search keyword' },
+        { name: 'query', positional: true, required: true, help: 'Search keyword' },
         { name: 'limit', type: 'int', default: 10, help: 'Max results' },
     ],
     columns: ['id', 'title', 'author', 'episodes', 'genre'],
     func: async (_page, args) => {
-        const term = encodeURIComponent(args.keyword);
+        const term = encodeURIComponent(args.query);
         const limit = Math.max(1, Math.min(Number(args.limit), 25));
         const data = await itunesFetch(`/search?term=${term}&media=podcast&limit=${limit}`);
         if (!data.results?.length)

package/dist/clis/apple-podcasts/top.js

@@ -1,7 +1,7 @@
 import { cli, Strategy } from '../../registry.js';
 import { CliError } from '../../errors.js';
 // Apple Marketing Tools RSS API — public, no key required
-const CHARTS_URL = 'https://rss.applemarketingtools.com/api/v2';
+const CHARTS_URL = 'https://rss.marketingtools.apple.com/api/v2';
 cli({
     site: 'apple-podcasts',
     name: 'top',
@@ -17,7 +17,14 @@ cli({
         const limit = Math.max(1, Math.min(Number(args.limit), 100));
         const country = String(args.country || 'us').trim().toLowerCase();
         const url = `${CHARTS_URL}/${country}/podcasts/top/${limit}/podcasts.json`;
-        const resp = await fetch(url);
+        let resp;
+        try {
+            resp = await fetch(url);
+        }
+        catch (error) {
+            const reason = error?.cause?.code ?? error?.message ?? 'unknown network error';
+            throw new CliError('FETCH_ERROR', `Unable to reach Apple Podcasts charts for ${country.toUpperCase()}`, `Apple charts may be temporarily unavailable (${reason}). Try again later.`);
+        }
         if (!resp.ok)
             throw new CliError('FETCH_ERROR', `Charts API HTTP ${resp.status}`, `Check country code: ${country}`);
         const data = await resp.json();

package/dist/clis/arxiv/paper.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { arxivFetch, parseEntries } from './utils.js';
+cli({
+    site: 'arxiv',
+    name: 'paper',
+    description: 'Get arXiv paper details by ID',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'arXiv paper ID (e.g. 1706.03762)' },
+    ],
+    columns: ['id', 'title', 'authors', 'published', 'abstract', 'url'],
+    func: async (_page, args) => {
+        const xml = await arxivFetch(`id_list=${encodeURIComponent(args.id)}`);
+        const entries = parseEntries(xml);
+        if (!entries.length)
+            throw new CliError('NOT_FOUND', `Paper ${args.id} not found`, 'Check the arXiv ID format, e.g. 1706.03762');
+        return entries;
+    },
+});

package/dist/clis/arxiv/search.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { arxivFetch, parseEntries } from './utils.js';
+cli({
+    site: 'arxiv',
+    name: 'search',
+    description: 'Search arXiv papers',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "attention is all you need")' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max results (max 25)' },
+    ],
+    columns: ['id', 'title', 'authors', 'published'],
+    func: async (_page, args) => {
+        const limit = Math.max(1, Math.min(Number(args.limit), 25));
+        const query = encodeURIComponent(`all:${args.keyword}`);
+        const xml = await arxivFetch(`search_query=${query}&max_results=${limit}&sortBy=relevance`);
+        const entries = parseEntries(xml);
+        if (!entries.length)
+            throw new CliError('NOT_FOUND', 'No papers found', 'Try a different keyword');
+        return entries.map(e => ({ id: e.id, title: e.title, authors: e.authors, published: e.published }));
+    },
+});

package/dist/clis/arxiv/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * arXiv adapter utilities.
+ *
+ * arXiv exposes a public Atom/XML API — no key required.
+ * https://info.arxiv.org/help/api/index.html
+ */
+export declare const ARXIV_BASE = "https://export.arxiv.org/api/query";
+export declare function arxivFetch(params: string): Promise<string>;
+export interface ArxivEntry {
+    id: string;
+    title: string;
+    authors: string;
+    abstract: string;
+    published: string;
+    url: string;
+}
+/** Parse Atom XML feed into structured entries. */
+export declare function parseEntries(xml: string): ArxivEntry[];