@aria-cli/tools 1.0.10 → 1.0.11

package/dist-cjs/definitions/browser/types.d.ts

@@ -0,0 +1,277 @@
+/**
+ * Shared browser tool types.
+ *
+ * Playwright types are referenced dynamically (the `playwright` package is an
+ * optional peer dependency loaded via `await import("playwright")`).
+ */
+/** Minimal Browser interface (matches Playwright's Browser). */
+export interface PwBrowser {
+    close(): Promise<void>;
+    contexts(): PwBrowserContext[];
+    isConnected(): boolean;
+}
+/** Minimal BrowserContext interface. */
+export interface PwBrowserContext {
+    pages(): PwPage[];
+    newPage(): Promise<PwPage>;
+    cookies(urls?: string | string[]): Promise<PwCookie[]>;
+    addCookies(cookies: PwCookie[]): Promise<void>;
+    clearCookies(): Promise<void>;
+    setOffline(offline: boolean): Promise<void>;
+    close(): Promise<void>;
+}
+/** Minimal Page interface. */
+export interface PwPage {
+    goto(url: string, options?: {
+        timeout?: number;
+        waitUntil?: "load" | "domcontentloaded" | "networkidle" | "commit";
+    }): Promise<unknown>;
+    url(): string;
+    title(): Promise<string>;
+    close(): Promise<void>;
+    content(): Promise<string>;
+    setViewportSize(size: {
+        width: number;
+        height: number;
+    }): Promise<void>;
+    screenshot(options?: {
+        type?: "png" | "jpeg";
+        fullPage?: boolean;
+    }): Promise<Buffer>;
+    evaluate<T>(fn: string | ((...args: unknown[]) => T), arg?: unknown): Promise<T>;
+    locator(selector: string): PwLocator;
+    getByRole(role: string, options?: {
+        name?: string;
+        exact?: boolean;
+    }): PwLocator;
+    keyboard: {
+        press(key: string, options?: {
+            delay?: number;
+        }): Promise<void>;
+    };
+    mouse: {
+        wheel(deltaX: number, deltaY: number): Promise<void>;
+    };
+    waitForTimeout(timeout: number): Promise<void>;
+    waitForSelector(selector: string, options?: {
+        timeout?: number;
+        state?: string;
+    }): Promise<unknown>;
+    waitForLoadState(state?: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    off(event: string, handler: (...args: unknown[]) => void): void;
+    isClosed(): boolean;
+    frameLocator(selector: string): PwFrameLocator;
+}
+export interface PwFrameLocator {
+    locator(selector: string): PwLocator;
+    getByRole(role: string, options?: {
+        name?: string;
+        exact?: boolean;
+    }): PwLocator;
+}
+export interface PwLocator {
+    click(options?: {
+        timeout?: number;
+        button?: string;
+        modifiers?: string[];
+    }): Promise<void>;
+    dblclick(options?: {
+        timeout?: number;
+        button?: string;
+        modifiers?: string[];
+    }): Promise<void>;
+    fill(value: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    type(text: string, options?: {
+        timeout?: number;
+        delay?: number;
+    }): Promise<void>;
+    press(key: string, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    hover(options?: {
+        timeout?: number;
+    }): Promise<void>;
+    selectOption(values: string | string[], options?: {
+        timeout?: number;
+    }): Promise<string[]>;
+    dragTo(target: PwLocator, options?: {
+        timeout?: number;
+    }): Promise<void>;
+    setInputFiles(files: string | string[]): Promise<void>;
+    highlight(): Promise<void>;
+    screenshot(options?: {
+        type?: "png" | "jpeg";
+    }): Promise<Buffer>;
+    scrollIntoViewIfNeeded(options?: {
+        timeout?: number;
+    }): Promise<void>;
+    boundingBox(): Promise<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null>;
+    elementHandle(): Promise<PwElementHandle | null>;
+    nth(index: number): PwLocator;
+    first(): PwLocator;
+    waitFor(options?: {
+        state?: string;
+        timeout?: number;
+    }): Promise<void>;
+    ariaSnapshot(): Promise<string>;
+    setChecked(checked: boolean, options?: {
+        timeout?: number;
+    }): Promise<void>;
+}
+export interface PwElementHandle {
+    evaluate<T>(fn: (el: Element, ...args: unknown[]) => T, ...args: unknown[]): Promise<T>;
+}
+export interface PwCookie {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    url?: string;
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "Lax" | "None" | "Strict";
+}
+export interface BrowserSession {
+    browser: PwBrowser;
+    context: PwBrowserContext;
+    page: PwPage;
+}
+export interface RoleRef {
+    role: string;
+    name?: string;
+    /** Index used only when role+name duplicates exist. */
+    nth?: number;
+}
+export type RoleRefMap = Record<string, RoleRef>;
+export interface RoleSnapshotStats {
+    lines: number;
+    chars: number;
+    refs: number;
+    interactive: number;
+}
+export interface SnapshotResult {
+    /** Text representation of accessibility tree */
+    snapshot: string;
+    refs: RoleRefMap;
+    stats: RoleSnapshotStats;
+    url: string;
+    title: string;
+}
+export interface BrowserConsoleMessage {
+    type: string;
+    text: string;
+    timestamp: string;
+}
+export interface BrowserNetworkRequest {
+    id: string;
+    timestamp: string;
+    method: string;
+    url: string;
+    status?: number;
+    resourceType?: string;
+    ok?: boolean;
+    failureText?: string;
+}
+export interface BrowserPageError {
+    message: string;
+    name?: string;
+    timestamp: string;
+}
+export type BrowserAction = {
+    action: "launch";
+    url?: string;
+    headless?: boolean;
+} | {
+    action: "close";
+} | {
+    action: "navigate";
+    url: string;
+} | {
+    action: "snapshot";
+    interactive?: boolean;
+} | {
+    action: "click";
+    ref: string;
+    button?: "left" | "right" | "middle";
+    modifiers?: string[];
+    doubleClick?: boolean;
+} | {
+    action: "type";
+    ref: string;
+    text: string;
+    submit?: boolean;
+    slowly?: boolean;
+} | {
+    action: "hover";
+    ref: string;
+} | {
+    action: "drag";
+    startRef: string;
+    endRef: string;
+} | {
+    action: "select_option";
+    ref: string;
+    values: string[];
+} | {
+    action: "press_key";
+    key: string;
+} | {
+    action: "scroll";
+    direction: "up" | "down";
+    amount?: number;
+} | {
+    action: "evaluate";
+    script: string;
+} | {
+    action: "screenshot";
+} | {
+    action: "get_console";
+    level?: string;
+} | {
+    action: "get_network";
+    filter?: string;
+} | {
+    action: "wait";
+    selector?: string;
+    text?: string;
+    timeout?: number;
+} | {
+    action: "tab_list";
+} | {
+    action: "tab_new";
+    url?: string;
+} | {
+    action: "tab_select";
+    index: number;
+} | {
+    action: "tab_close";
+    index?: number;
+} | {
+    action: "cookies_get";
+    url?: string;
+} | {
+    action: "cookies_set";
+    cookies: Array<{
+        name: string;
+        value: string;
+        domain: string;
+        path?: string;
+    }>;
+} | {
+    action: "cookies_clear";
+} | {
+    action: "upload";
+    ref: string;
+    paths: string[];
+};

package/dist-cjs/definitions/browser/types.js

@@ -0,0 +1,6 @@
+"use strict";
+// Originally from OpenClaw (MIT License, Copyright 2025 Peter Steinberger)
+// https://github.com/openclaw/openclaw
+// Modified for ARIA — stripped OpenClaw runtime, rewired to ARIA Tool interface
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist-cjs/definitions/browser/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/definitions/browser/types.ts"],"names":[],"mappings":";AAAA,2EAA2E;AAC3E,uCAAuC;AACvC,gFAAgF"}

package/dist-cjs/definitions/code-intelligence.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Code intelligence tool definitions
+ *
+ * 7 native tools wrapping external CLI binaries for code search, structural
+ * analysis, knowledge graphs, LSP intelligence, and file discovery.
+ */
+import type { Tool } from "../types.js";
+export declare const CODE_INTELLIGENCE_TOOL_DEFINITIONS: Tool[];