@jackwener/opencli 1.0.6 → 1.1.1

package/src/clis/antigravity/serve.ts

@@ -81,76 +81,274 @@ function sleep(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+// ─── DOM helpers ─────────────────────────────────────────────────────
+
+/**
+ * Click the 'New Conversation' button to reset context.
+ */
+async function startNewConversation(page: IPage): Promise<void> {
+  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: IPage, anthropicModelId: string): Promise<void> {
+  // 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: IPage): Promise<boolean> {
+  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: Element | null, depth = 0): Element | null {
+  if (!root || depth > 12) return null;
+  const nonEmpty = Array.from(root.children).filter(
+    c => (c as HTMLElement).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: IPage): Promise<string> {
   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: IPage, message: string): Promise<void> {
-  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: IPage, userText?: string): Promise<string> {
+  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: IPage, message: string, bridge?: CDPBridge): Promise<void> {
+  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: IPage,
   beforeText: string,
-  opts: { timeout?: number; pollInterval?: number; stableThreshold?: number } = {},
-): Promise<string> {
+  opts: { timeout?: number; pollInterval?: number } = {},
+): Promise<void> {
   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;
-  let lastText = beforeText;
-  let stableCount = 0;
 
-  // Wait a bit for the model to start generating
+  // 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;
+  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;
+      }
+      
+      // 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;
         }
-      } else {
-        // Still generating
-        stableCount = 0;
-        lastText = current;
       }
     }
 
     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');
 }
 
@@ -159,6 +357,7 @@ async function waitForReply(
 async function handleMessages(
   body: AnthropicRequest,
   page: IPage,
+  bridge?: CDPBridge,
 ): Promise<AnthropicResponse> {
   // Extract the last user message
   const userMessages = body.messages.filter(m => m.role === 'user');
@@ -172,16 +371,30 @@ async function handleMessages(
     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);
+  await sendMessage(page, userText, bridge);
 
-  // Poll for reply
+  // 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 {
@@ -204,17 +417,74 @@ async function handleMessages(
 export async function startServe(opts: { port?: number } = {}): Promise<void> {
   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.');
+  // Lazy CDP connection — connect when first request comes in
+  let cdp: CDPBridge | null = null;
+  let page: IPage | null = null;
+  let requestInFlight = false;
 
-  // Verify we can read conversation
-  const testText = await getConversationText(page);
-  console.error(`[serve] Conversation element found (${testText.length} chars).`);
+  async function ensureConnected(): Promise<IPage> {
+    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;
+      }
+    }
 
-  let requestInFlight = false;
+    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() as Array<{ title?: string; type?: string }>;
+      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: any) {
+      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
@@ -266,7 +536,6 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
           const body = JSON.parse(rawBody) as AnthropicRequest;
 
           if (body.stream) {
-            // We don't support streaming — return error
             jsonResponse(res, 400, {
               type: 'error',
               error: {
@@ -277,7 +546,9 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
             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 {
           requestInFlight = false;
@@ -287,7 +558,7 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
 
       // 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;
       }
 
@@ -296,7 +567,7 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
         error: { type: 'not_found_error', message: `Not found: ${pathname}` },
       });
     } catch (err) {
-      console.error('[serve] Error:', err);
+      console.error('[serve] Error:', err instanceof Error ? err.message : err);
       jsonResponse(res, 500, {
         type: 'error',
         error: {
@@ -310,6 +581,7 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
   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`);
   });
@@ -317,7 +589,7 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
   // Graceful shutdown
   const shutdown = () => {
     console.error('\n[serve] Shutting down...');
-    cdp.close().catch(() => {});
+    cdp?.close().catch(() => {});
     server.close();
     process.exit(0);
   };
@@ -327,3 +599,4 @@ export async function startServe(opts: { port?: number } = {}): Promise<void> {
   // Keep alive
   await new Promise(() => {});
 }
+

package/src/clis/apple-podcasts/commands.test.ts

@@ -0,0 +1,95 @@
+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 as any, {
+      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 as any, { 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 as any, { country: 'us', limit: 3 })).rejects.toThrow(
+      'Unable to reach Apple Podcasts charts for US',
+    );
+  });
+});

package/src/clis/apple-podcasts/search.ts

@@ -9,12 +9,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) throw new CliError('NOT_FOUND', 'No podcasts found', `Try a different keyword`);

package/src/clis/apple-podcasts/top.ts

@@ -2,7 +2,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',
@@ -19,7 +19,17 @@ 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: Response;
+    try {
+      resp = await fetch(url);
+    } catch (error: any) {
+      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();
     const results = data?.feed?.results;

package/src/clis/arxiv/paper.ts

@@ -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/src/clis/arxiv/search.ts

@@ -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 }));
+  },
+});