@huyuan-ai/cli 1.0.0 → 1.0.1

package/vendor/opencli/dist/clis/amazon/shared.d.ts

@@ -0,0 +1,75 @@
+import type { IPage } from '../../types.js';
+export declare const SITE = "amazon";
+export declare const DOMAIN = "amazon.com";
+export declare const HOME_URL = "https://www.amazon.com/";
+export declare const BESTSELLERS_URL = "https://www.amazon.com/Best-Sellers/zgbs";
+export declare const NEW_RELEASES_URL = "https://www.amazon.com/gp/new-releases";
+export declare const MOVERS_SHAKERS_URL = "https://www.amazon.com/gp/movers-and-shakers";
+export declare const SEARCH_URL_PREFIX = "https://www.amazon.com/s?k=";
+export declare const PRODUCT_URL_PREFIX = "https://www.amazon.com/dp/";
+export declare const DISCUSSION_URL_PREFIX = "https://www.amazon.com/product-reviews/";
+export declare const STRATEGY = "cookie";
+export declare const PRIMARY_PRICE_SELECTORS: string[];
+export type AmazonRankingListType = 'bestsellers' | 'new_releases' | 'movers_shakers';
+export interface ProvenanceFields {
+    source_url: string;
+    fetched_at: string;
+    strategy: string;
+}
+export interface PageState {
+    href: string;
+    title: string;
+    body_text: string;
+}
+export interface PriceValue {
+    price_text: string | null;
+    price_value: number | null;
+    currency: string | null;
+}
+export declare function cleanText(value: unknown): string;
+export declare function cleanMultilineText(value: unknown): string;
+export declare function uniqueNonEmpty(values: Array<string | null | undefined>): string[];
+export declare function buildProvenance(sourceUrl: string): ProvenanceFields;
+export declare function buildSearchUrl(query: string): string;
+export declare function extractAsin(input: string): string | null;
+export declare function buildProductUrl(input: string): string;
+export declare function buildDiscussionUrl(input: string): string;
+export declare function isSupportedRankingPath(listType: AmazonRankingListType, inputUrl: string): boolean;
+export declare function resolveRankingUrl(listType: AmazonRankingListType, input?: string): string;
+export declare function isRankingPaginationUrl(listType: AmazonRankingListType, inputUrl: string): boolean;
+export declare function extractCategoryNodeId(inputUrl: string | null | undefined): string | null;
+export declare function resolveBestsellersUrl(input?: string): string;
+export declare function canonicalizeAmazonUrl(input: string): string;
+export declare function toAbsoluteAmazonUrl(value: string | null | undefined): string | null;
+export declare function normalizeProductUrl(value: string | null | undefined): string | null;
+export declare function parsePriceText(text: string | null | undefined): PriceValue;
+export declare function parseRatingValue(text: string | null | undefined): number | null;
+export declare function parseReviewCount(text: string | null | undefined): number | null;
+export declare function extractReviewCountFromCardText(text: string | null | undefined): string | null;
+export declare function isAmazonEntity(text: string | null | undefined): boolean;
+export declare function firstMeaningfulLine(text: string | null | undefined): string;
+export declare function trimRatingPrefix(text: string | null | undefined): string | null;
+export declare function isRobotState(state: Partial<PageState>): boolean;
+export declare function buildChallengeHint(action: string): string;
+export declare function readPageState(page: IPage): Promise<PageState>;
+export declare function gotoAndReadState(page: IPage, url: string, settleMs?: number, action?: string): Promise<PageState>;
+export declare function assertUsableState(state: PageState, action: string): void;
+export declare const __test__: {
+    buildSearchUrl: typeof buildSearchUrl;
+    extractAsin: typeof extractAsin;
+    buildProductUrl: typeof buildProductUrl;
+    buildDiscussionUrl: typeof buildDiscussionUrl;
+    resolveBestsellersUrl: typeof resolveBestsellersUrl;
+    resolveRankingUrl: typeof resolveRankingUrl;
+    isSupportedRankingPath: typeof isSupportedRankingPath;
+    isRankingPaginationUrl: typeof isRankingPaginationUrl;
+    extractCategoryNodeId: typeof extractCategoryNodeId;
+    parsePriceText: typeof parsePriceText;
+    parseRatingValue: typeof parseRatingValue;
+    parseReviewCount: typeof parseReviewCount;
+    extractReviewCountFromCardText: typeof extractReviewCountFromCardText;
+    isAmazonEntity: typeof isAmazonEntity;
+    trimRatingPrefix: typeof trimRatingPrefix;
+    isRobotState: typeof isRobotState;
+    PRIMARY_PRICE_SELECTORS: string[];
+};

package/vendor/opencli/dist/clis/amazon/shared.js

@@ -0,0 +1,365 @@
+import { ArgumentError, CommandExecutionError } from '../../errors.js';
+export const SITE = 'amazon';
+export const DOMAIN = 'amazon.com';
+export const HOME_URL = 'https://www.amazon.com/';
+export const BESTSELLERS_URL = 'https://www.amazon.com/Best-Sellers/zgbs';
+export const NEW_RELEASES_URL = 'https://www.amazon.com/gp/new-releases';
+export const MOVERS_SHAKERS_URL = 'https://www.amazon.com/gp/movers-and-shakers';
+export const SEARCH_URL_PREFIX = 'https://www.amazon.com/s?k=';
+export const PRODUCT_URL_PREFIX = 'https://www.amazon.com/dp/';
+export const DISCUSSION_URL_PREFIX = 'https://www.amazon.com/product-reviews/';
+export const STRATEGY = 'cookie';
+export const PRIMARY_PRICE_SELECTORS = [
+    '#corePrice_feature_div .a-offscreen',
+    '#corePriceDisplay_desktop_feature_div .a-offscreen',
+    '#corePrice_desktop .a-offscreen',
+    '#apex_desktop .a-offscreen',
+    '#newAccordionRow_0 .a-offscreen',
+    '#price_inside_buybox',
+    '#priceblock_ourprice',
+    '#priceblock_dealprice',
+    '#tp_price_block_total_price_ww',
+];
+const ROBOT_TEXT_PATTERNS = [
+    'Sorry, we just need to make sure you\'re not a robot',
+    'Enter the characters you see below',
+    'Type the characters you see in this image',
+    'To discuss automated access to Amazon data please contact',
+];
+const AMAZON_RANKING_SPECS = {
+    bestsellers: {
+        commandName: 'bestsellers',
+        rootUrl: BESTSELLERS_URL,
+        pathPattern: /(?:^|\/)zgbs(?:\/|$)/i,
+        invalidInputMessage: 'amazon bestsellers expects a best sellers URL or /zgbs path',
+        invalidInputHint: 'Example: opencli amazon bestsellers https://www.amazon.com/Best-Sellers/zgbs',
+    },
+    new_releases: {
+        commandName: 'new-releases',
+        rootUrl: NEW_RELEASES_URL,
+        pathPattern: /\/gp\/new-releases(?:\/|$)/i,
+        invalidInputMessage: 'amazon new-releases expects a new releases URL or /gp/new-releases path',
+        invalidInputHint: 'Example: opencli amazon new-releases https://www.amazon.com/gp/new-releases',
+    },
+    movers_shakers: {
+        commandName: 'movers-shakers',
+        rootUrl: MOVERS_SHAKERS_URL,
+        pathPattern: /\/gp\/movers-and-shakers(?:\/|$)/i,
+        invalidInputMessage: 'amazon movers-shakers expects a movers-and-shakers URL or /gp/movers-and-shakers path',
+        invalidInputHint: 'Example: opencli amazon movers-shakers https://www.amazon.com/gp/movers-and-shakers',
+    },
+};
+export function cleanText(value) {
+    return typeof value === 'string'
+        ? value.replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim()
+        : '';
+}
+export function cleanMultilineText(value) {
+    return typeof value === 'string'
+        ? value
+            .replace(/\u00a0/g, ' ')
+            .split('\n')
+            .map((line) => line.replace(/\s+/g, ' ').trim())
+            .filter(Boolean)
+            .join('\n')
+        : '';
+}
+export function uniqueNonEmpty(values) {
+    return [...new Set(values.map((value) => cleanText(value)).filter(Boolean))];
+}
+export function buildProvenance(sourceUrl) {
+    return {
+        source_url: sourceUrl,
+        fetched_at: new Date().toISOString(),
+        strategy: STRATEGY,
+    };
+}
+export function buildSearchUrl(query) {
+    const normalized = cleanText(query);
+    if (!normalized) {
+        throw new ArgumentError('amazon search query cannot be empty');
+    }
+    return `${SEARCH_URL_PREFIX}${encodeURIComponent(normalized)}`;
+}
+export function extractAsin(input) {
+    const normalized = cleanText(input);
+    if (!normalized)
+        return null;
+    if (/^[A-Z0-9]{10}$/i.test(normalized)) {
+        return normalized.toUpperCase();
+    }
+    const match = normalized.match(/\/(?:dp|gp\/product|product-reviews)\/([A-Z0-9]{10})/i);
+    return match ? match[1].toUpperCase() : null;
+}
+export function buildProductUrl(input) {
+    const asin = extractAsin(input);
+    if (!asin) {
+        throw new ArgumentError('amazon product expects an ASIN or product URL', 'Example: opencli amazon product B0FJS72893');
+    }
+    return `${PRODUCT_URL_PREFIX}${asin}`;
+}
+export function buildDiscussionUrl(input) {
+    const asin = extractAsin(input);
+    if (!asin) {
+        throw new ArgumentError('amazon discussion expects an ASIN or product URL', 'Example: opencli amazon discussion B0FJS72893');
+    }
+    return `${DISCUSSION_URL_PREFIX}${asin}`;
+}
+function getRankingSpec(listType) {
+    return AMAZON_RANKING_SPECS[listType];
+}
+export function isSupportedRankingPath(listType, inputUrl) {
+    try {
+        const url = new URL(inputUrl);
+        return getRankingSpec(listType).pathPattern.test(url.pathname);
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveRankingUrl(listType, input) {
+    const spec = getRankingSpec(listType);
+    const normalized = cleanText(input);
+    if (!normalized || normalized === 'root')
+        return spec.rootUrl;
+    let candidateUrl;
+    if (normalized.startsWith('/')) {
+        candidateUrl = new URL(normalized, HOME_URL).toString();
+    }
+    else if (/^https?:\/\//i.test(normalized)) {
+        candidateUrl = canonicalizeAmazonUrl(normalized);
+    }
+    else if (normalized.includes('amazon.') && normalized.includes('/')) {
+        candidateUrl = canonicalizeAmazonUrl(`https://${normalized.replace(/^\/+/, '')}`);
+    }
+    else {
+        throw new ArgumentError(spec.invalidInputMessage, spec.invalidInputHint);
+    }
+    if (!isSupportedRankingPath(listType, candidateUrl)) {
+        throw new ArgumentError(spec.invalidInputMessage, spec.invalidInputHint);
+    }
+    return normalizeRankingInputUrl(candidateUrl);
+}
+function normalizeRankingInputUrl(inputUrl) {
+    try {
+        const url = new URL(inputUrl);
+        const normalizedPathSegments = url.pathname
+            .split('/')
+            .filter(Boolean)
+            .filter((segment) => !/^ref=/i.test(segment));
+        url.pathname = `/${normalizedPathSegments.join('/')}`;
+        url.hash = '';
+        // Ranking pages are frequently shared with tracking refs that can land on unstable variants.
+        // Dropping ref keeps the canonical ranking path while preserving useful params (for example pg=2).
+        url.searchParams.delete('ref');
+        return url.toString();
+    }
+    catch {
+        return inputUrl;
+    }
+}
+export function isRankingPaginationUrl(listType, inputUrl) {
+    const absolute = toAbsoluteAmazonUrl(inputUrl);
+    if (!absolute || !isSupportedRankingPath(listType, absolute))
+        return false;
+    try {
+        const url = new URL(absolute);
+        const ref = cleanText(url.searchParams.get('ref')).toLowerCase();
+        // pg= query param is the most reliable pagination indicator across all ranking lists
+        return url.searchParams.has('pg')
+            || /(?:^|_)pg(?:_|$)/.test(ref)
+            // Amazon ranking pagination refs: zg_bs_pg_ (bestsellers), zg_bsnr_pg_ (new releases), zg_bsms_pg_ (movers & shakers)
+            || /zg_bs(?:nr|ms)?_pg_/.test(ref);
+    }
+    catch {
+        return false;
+    }
+}
+export function extractCategoryNodeId(inputUrl) {
+    const absolute = toAbsoluteAmazonUrl(inputUrl);
+    if (!absolute)
+        return null;
+    try {
+        const url = new URL(absolute);
+        for (const key of ['node', 'nodeid', 'nodeId', 'browseNode']) {
+            const value = cleanText(url.searchParams.get(key));
+            if (/^\d{4,}$/.test(value))
+                return value;
+        }
+        const rhValue = cleanText(url.searchParams.get('rh'));
+        const rhMatch = decodeURIComponent(rhValue).match(/(?:^|,)\s*n:(\d{4,})(?:,|$)/i);
+        if (rhMatch)
+            return rhMatch[1];
+        const pathMatches = [...url.pathname.matchAll(/\/(\d{4,})(?=\/|$)/g)];
+        if (pathMatches.length > 0) {
+            return pathMatches[pathMatches.length - 1][1];
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function resolveBestsellersUrl(input) {
+    return resolveRankingUrl('bestsellers', input);
+}
+export function canonicalizeAmazonUrl(input) {
+    try {
+        const url = new URL(input);
+        if (!url.hostname.endsWith(DOMAIN)) {
+            throw new Error('not-amazon');
+        }
+        return url.toString();
+    }
+    catch {
+        throw new ArgumentError('Invalid Amazon URL');
+    }
+}
+export function toAbsoluteAmazonUrl(value) {
+    const normalized = cleanText(value);
+    if (!normalized)
+        return null;
+    try {
+        return new URL(normalized, HOME_URL).toString();
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeProductUrl(value) {
+    const normalized = cleanText(value);
+    const asin = extractAsin(normalized);
+    if (asin)
+        return buildProductUrl(asin);
+    return toAbsoluteAmazonUrl(normalized);
+}
+export function parsePriceText(text) {
+    const normalized = cleanText(text);
+    const match = normalized.match(/([$€£])\s*(\d+(?:,\d{3})*(?:\.\d+)?)/);
+    if (!match) {
+        return {
+            price_text: normalized || null,
+            price_value: null,
+            currency: null,
+        };
+    }
+    const currencyMap = {
+        '$': 'USD',
+        '€': 'EUR',
+        '£': 'GBP',
+    };
+    return {
+        price_text: `${match[1]}${match[2]}`,
+        price_value: Number.parseFloat(match[2].replace(/,/g, '')),
+        currency: currencyMap[match[1]] ?? null,
+    };
+}
+export function parseRatingValue(text) {
+    const normalized = cleanText(text);
+    const match = normalized.match(/(\d+(?:\.\d+)?)\s*out of 5/i);
+    return match ? Number.parseFloat(match[1]) : null;
+}
+export function parseReviewCount(text) {
+    const normalized = cleanText(text);
+    const compactMatch = normalized.match(/(\d+(?:\.\d+)?)\s*([kKmM])/);
+    if (compactMatch) {
+        const value = Number.parseFloat(compactMatch[1]);
+        const multiplier = /m/i.test(compactMatch[2]) ? 1_000_000 : 1_000;
+        return Number.isFinite(value) ? Math.round(value * multiplier) : null;
+    }
+    const match = normalized.match(/([\d,]+)/);
+    return match ? Number.parseInt(match[1].replace(/,/g, ''), 10) : null;
+}
+export function extractReviewCountFromCardText(text) {
+    const normalized = cleanMultilineText(text);
+    const match = normalized.match(/out of 5 stars(?:, rating details)?\s*([\d,]+)/i);
+    if (match)
+        return match[1];
+    const numericLine = normalized
+        .split('\n')
+        .map((line) => cleanText(line))
+        .find((line) => /^[\d,]+$/.test(line));
+    return numericLine ?? null;
+}
+export function isAmazonEntity(text) {
+    const normalized = cleanText(text).toLowerCase();
+    return normalized.includes('amazon');
+}
+export function firstMeaningfulLine(text) {
+    return cleanMultilineText(text)
+        .split('\n')
+        .map((line) => cleanText(line))
+        .find(Boolean)
+        ?? '';
+}
+export function trimRatingPrefix(text) {
+    const normalized = cleanText(text);
+    if (!normalized)
+        return null;
+    return normalized.replace(/^\d+(?:\.\d+)?\s*out of 5 stars\s*/i, '').trim() || normalized;
+}
+export function isRobotState(state) {
+    const title = cleanText(state.title);
+    const bodyText = cleanMultilineText(state.body_text);
+    return ROBOT_TEXT_PATTERNS.some((pattern) => title.includes(pattern) || bodyText.includes(pattern));
+}
+export function buildChallengeHint(action) {
+    return [
+        `Open a clean Amazon ${action} page in the shared Chrome profile and clear any robot check first.`,
+        'If you are using CDP, set OPENCLI_CDP_TARGET=amazon.com and avoid parallel Amazon commands against the same browser target.',
+    ].join(' ');
+}
+export async function readPageState(page) {
+    const result = await page.evaluate(`
+    (() => ({
+      href: window.location.href,
+      title: document.title || '',
+      body_text: document.body ? document.body.innerText || '' : '',
+    }))()
+  `);
+    return {
+        href: cleanText(result.href),
+        title: cleanText(result.title),
+        body_text: cleanMultilineText(result.body_text),
+    };
+}
+export async function gotoAndReadState(page, url, settleMs = 2500, action = 'page') {
+    try {
+        await page.goto(url, { settleMs });
+        await page.wait(1.5);
+        return await readPageState(page);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('Inspected target navigated or closed')
+            || message.includes('Cannot find context with specified id')
+            || message.includes('Target closed')) {
+            throw new CommandExecutionError(`amazon ${action} navigation lost the current browser target`, `${buildChallengeHint(action)} If CDP is attached to a stale tab, open a fresh Amazon tab and retry.`);
+        }
+        throw error;
+    }
+}
+export function assertUsableState(state, action) {
+    if (!isRobotState(state))
+        return;
+    throw new CommandExecutionError(`amazon ${action} hit a robot check`, buildChallengeHint(action));
+}
+export const __test__ = {
+    buildSearchUrl,
+    extractAsin,
+    buildProductUrl,
+    buildDiscussionUrl,
+    resolveBestsellersUrl,
+    resolveRankingUrl,
+    isSupportedRankingPath,
+    isRankingPaginationUrl,
+    extractCategoryNodeId,
+    parsePriceText,
+    parseRatingValue,
+    parseReviewCount,
+    extractReviewCountFromCardText,
+    isAmazonEntity,
+    trimRatingPrefix,
+    isRobotState,
+    PRIMARY_PRICE_SELECTORS,
+};

package/vendor/opencli/dist/clis/amazon/shared.test.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/opencli/dist/clis/amazon/shared.test.js

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './shared.js';
+describe('amazon shared helpers', () => {
+    it('builds canonical product and discussion URLs from ASINs and product URLs', () => {
+        expect(__test__.buildProductUrl('B0FJS72893')).toBe('https://www.amazon.com/dp/B0FJS72893');
+        expect(__test__.buildProductUrl('https://www.amazon.com/dp/B0FJS72893/ref=something')).toBe('https://www.amazon.com/dp/B0FJS72893');
+        expect(__test__.buildDiscussionUrl('https://www.amazon.com/dp/B0FJS72893')).toBe('https://www.amazon.com/product-reviews/B0FJS72893');
+    });
+    it('parses price, rating, and review-count text', () => {
+        expect(__test__.parsePriceText('1 offer from $34.11')).toEqual({
+            price_text: '$34.11',
+            price_value: 34.11,
+            currency: 'USD',
+        });
+        expect(__test__.parseRatingValue('3.9 out of 5 stars, rating details')).toBe(3.9);
+        expect(__test__.parseReviewCount('27 global ratings')).toBe(27);
+        expect(__test__.parseReviewCount('(2.9K)')).toBe(2900);
+        expect(__test__.parseReviewCount('1.2M global ratings')).toBe(1200000);
+        expect(__test__.extractReviewCountFromCardText('Desk Shelf\n4.3 out of 5 stars\n435\n$25.92')).toBe('435');
+    });
+    it('recognizes robot checks and Amazon-owned merchants', () => {
+        expect(__test__.isAmazonEntity('Ships from Amazon')).toBe(true);
+        expect(__test__.trimRatingPrefix('5.0 out of 5 stars Great value and quality')).toBe('Great value and quality');
+        expect(__test__.isRobotState({
+            title: 'Robot Check',
+            body_text: 'Sorry, we just need to make sure you\'re not a robot',
+        })).toBe(true);
+    });
+    it('requires a real best-sellers URL or path', () => {
+        expect(__test__.resolveBestsellersUrl('/Best-Sellers/zgbs')).toBe('https://www.amazon.com/Best-Sellers/zgbs');
+        expect(() => __test__.resolveBestsellersUrl('desk shelf organizer')).toThrow('amazon bestsellers expects a best sellers URL or /zgbs path');
+    });
+    it('resolves and validates all ranking list URLs', () => {
+        expect(__test__.resolveRankingUrl('new_releases')).toBe('https://www.amazon.com/gp/new-releases');
+        expect(__test__.resolveRankingUrl('movers_shakers')).toBe('https://www.amazon.com/gp/movers-and-shakers');
+        expect(__test__.resolveRankingUrl('new_releases', '/gp/new-releases/kitchen')).toBe('https://www.amazon.com/gp/new-releases/kitchen');
+        expect(__test__.resolveRankingUrl('bestsellers', 'https://www.amazon.com/Best-Sellers/zgbs/ref=zg_bsnr_tab_bs')).toBe('https://www.amazon.com/Best-Sellers/zgbs');
+        expect(() => __test__.resolveRankingUrl('movers_shakers', 'https://example.com/gp/movers-and-shakers')).toThrow('Invalid Amazon URL');
+    });
+    it('extracts category node id from URL best effort', () => {
+        expect(__test__.extractCategoryNodeId('https://www.amazon.com/Best-Sellers-Home-Kitchen/zgbs/home-garden/3744371')).toBe('3744371');
+        expect(__test__.extractCategoryNodeId('https://www.amazon.com/s?k=desk+organizer&rh=n%3A1064954')).toBe('1064954');
+    });
+});

package/vendor/opencli/dist/clis/antigravity/dump.d.ts

@@ -0,0 +1 @@
+export declare const dumpCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/antigravity/dump.js

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import * as fs from 'node:fs';
+export const dumpCommand = cli({
+    site: 'antigravity',
+    name: 'dump',
+    description: 'Dump the DOM to help AI understand the UI',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['htmlFile', 'snapFile'],
+    func: async (page) => {
+        // Extract HTML
+        const html = await page.evaluate('document.body.innerHTML');
+        fs.writeFileSync('/tmp/antigravity-dom.html', html);
+        // Extract Snapshot
+        let snapFile = '';
+        try {
+            const snap = await page.snapshot({ raw: true });
+            snapFile = '/tmp/antigravity-snapshot.json';
+            fs.writeFileSync(snapFile, JSON.stringify(snap, null, 2));
+        }
+        catch (e) {
+            snapFile = 'Failed';
+        }
+        return [{ htmlFile: '/tmp/antigravity-dom.html', snapFile }];
+    },
+});

package/vendor/opencli/dist/clis/antigravity/extract-code.d.ts

@@ -0,0 +1 @@
+export declare const extractCodeCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/antigravity/extract-code.js

@@ -0,0 +1,32 @@
+import { cli, Strategy } from '../../registry.js';
+export const extractCodeCommand = cli({
+    site: 'antigravity',
+    name: 'extract-code',
+    description: 'Extract multi-line code blocks from the current Antigravity conversation',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['code'],
+    func: async (page) => {
+        const blocks = await page.evaluate(`
+      async () => {
+        // Find standard pre/code blocks
+        let elements = Array.from(document.querySelectorAll('pre code'));
+        
+        // Fallback to Monaco editor content inside the UI
+        if (elements.length === 0) {
+          elements = Array.from(document.querySelectorAll('.monaco-editor'));
+        }
+        
+        // Generic fallback to any code tag that spans multiple lines
+        if (elements.length === 0) {
+          elements = Array.from(document.querySelectorAll('code')).filter(c => c.innerText.includes('\\n'));
+        }
+        
+        return elements.map(el => el.innerText).filter(text => text.trim().length > 0);
+      }
+    `);
+        return blocks.map((code) => ({ code }));
+    },
+});

package/vendor/opencli/dist/clis/antigravity/model.d.ts

@@ -0,0 +1 @@
+export declare const modelCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/antigravity/model.js

@@ -0,0 +1,44 @@
+import { cli, Strategy } from '../../registry.js';
+export const modelCommand = cli({
+    site: 'antigravity',
+    name: 'model',
+    description: 'Switch the active LLM model in Antigravity',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'name', help: 'Target model name (e.g. claude, gemini, o1)', required: true, positional: true }
+    ],
+    columns: ['Status'],
+    func: async (page, kwargs) => {
+        const targetName = kwargs.name.toLowerCase();
+        await page.evaluate(`
+      async () => {
+        const targetModelName = ${JSON.stringify(targetName)};
+        
+        // 1. Locate the model selector dropdown trigger
+        const trigger = document.querySelector('div[aria-haspopup="dialog"] > div[tabindex="0"]');
+        if (!trigger) throw new Error('Could not find the model selector trigger in the UI');
+        trigger.click();
+        
+        // 2. Wait a brief moment for React to mount the Portal/Dialog
+        await new Promise(r => setTimeout(r, 200));
+        
+        // 3. Find the option spanning target text
+        const spans = Array.from(document.querySelectorAll('[role="dialog"] span'));
+        const target = spans.find(s => s.innerText.toLowerCase().includes(targetModelName));
+        if (!target) {
+          // If not found, click the trigger again to close it safely
+          trigger.click();
+          throw new Error('Model matching "' + targetModelName + '" was not found in the dropdown list.');
+        }
+        
+        // 4. Click the closest parent that handles the row action
+        const optionNode = target.closest('.cursor-pointer') || target;
+        optionNode.click();
+      }
+    `);
+        await page.wait(0.5);
+        return [{ Status: `Model switched to: ${kwargs.name}` }];
+    },
+});

package/vendor/opencli/dist/clis/antigravity/new.d.ts

@@ -0,0 +1 @@
+export declare const newCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/antigravity/new.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+export const newCommand = cli({
+    site: 'antigravity',
+    name: 'new',
+    description: 'Start a new conversation / clear context in Antigravity',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['status'],
+    func: async (page) => {
+        await page.evaluate(`
+      async () => {
+        const btn = document.querySelector('[data-tooltip-id="new-conversation-tooltip"]');
+        if (!btn) throw new Error('Could not find New Conversation button');
+        
+        // In case it's disabled, we must check, but we'll try to click it anyway
+        btn.click();
+      }
+    `);
+        // Give it a moment to reset the UI
+        await page.wait(0.5);
+        return [{ status: 'Successfully started a new conversation' }];
+    },
+});

package/vendor/opencli/dist/clis/antigravity/read.d.ts

@@ -0,0 +1 @@
+export declare const readCommand: import("../../registry.js").CliCommand;

package/vendor/opencli/dist/clis/antigravity/read.js

@@ -0,0 +1,34 @@
+import { cli, Strategy } from '../../registry.js';
+export const readCommand = cli({
+    site: 'antigravity',
+    name: 'read',
+    description: 'Read the latest chat messages from Antigravity AI',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'last', help: 'Number of recent messages to read (not fully implemented due to generic structure, currently returns full history text or latest chunk)' }
+    ],
+    columns: ['role', 'content'],
+    func: async (page, kwargs) => {
+        // We execute a script inside Antigravity's Chromium environment to extract the text 
+        // of the entire conversation pane.
+        const rawText = await page.evaluate(`
+      async () => {
+        const container = document.getElementById('conversation');
+        if (!container) throw new Error('Could not find conversation container');
+        
+        // Extract the full visible text of the conversation
+        // In Electron/Chromium, innerText preserves basic visual line breaks nicely
+        return container.innerText;
+      }
+    `);
+        // We can do simple heuristic parsing based on typical visual markers if needed.
+        // For now, we return the entire text blob, or just the last 2000 characters if it's too long.
+        const cleanText = String(rawText).trim();
+        return [{
+                role: 'history',
+                content: cleanText
+            }];
+    },
+});