@eko-ai/eko 1.0.1 → 1.0.2

package/README.md

@@ -1,70 +1,82 @@
-# **Eko**
+# Eko
 
-[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)  [![Build Status](https://img.shields.io/badge/build-passing-brightgreen.svg)](https://example.com/build-status)  [![Version](https://img.shields.io/badge/version-0.1.0-yellow.svg)](https://example.com/version)  
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE) [![Build Status](https://img.shields.io/badge/build-passing-brightgreen.svg)](https://example.com/build-status) [![Version](https://img.shields.io/badge/version-0.1.0-yellow.svg)](https://example.com/version)
 
 **Eko** is a revolutionary framework designed to empower developers and users alike to program their browser and operating system using natural language. With seamless integration of browser APIs, OS-level capabilities, and cutting-edge AI tools like Claude 3.5, Eko redefines how we interact with technology, making it intuitive, powerful, and accessible.
 
----
+## Key Features
 
-## **Table of Contents**
+- **Natural Language Programming**: Transform human instructions into executable actions using advanced AI models
+- **Cross-Platform Operation**: Run in browser extensions, web applications, or Node.js environments
+- **Powerful Tooling**: Built-in tools for browser automation, OS operations, and system control
+- **Flexible Integration**: Seamless integration with Claude 3.5 and other LLM models
+- **Developer-Friendly**: Comprehensive TypeScript support and extensive documentation
 
-1. [Introduction](#introduction)  
-2. [Features](#features)  
-3. [Installation](#installation)  
-4. [Usage](#usage)  
-5. [API Documentation](#api-documentation)  
-6. [Contributing](#contributing)  
-7. [License](#license)  
+## Quick Start
 
----
+```bash
+npm install @eko-ai/eko
+```
 
-## **Introduction**
+```typescript
+import { Eko } from '@eko-ai/eko';
 
-**Eko** is a full-stack agent development framework built on the [Fellou AI browser](https://fellou.ai), which transforms human words into actions. By leveraging natural language processing and advanced AI capabilities, it bridges the gap between user intent and system execution. Whether you're automating workflows, building browser agents, or accessing system-level operations, Eko provides the tools to make it effortless.  
+const eko = new Eko({
+  apiKey: 'your_anthropic_api_key',
+});
 
-## **Why use the Eko**
-- The biggest advantage of using Eko is that developers don’t need to build client software, and users don’t need to install any additional client to enjoy the most advanced AI-powered computer use capabilities. These capabilities span across both the browser and the operating system.
-- **Eko** changes the paradigm of programming, shifting from developers telling computers how to do something to developers telling computers what to do and what goals to achieve.
+// Example: Browser automation
+await eko.run("Search for 'Eko framework' on Google and save the first result");
 
+// Example: System operation
+await eko.run("Create a new folder named 'reports' and move all PDF files there");
+```
 
-### **Key Benefits**
-- **Language as Code**: Use natural language to write commands and create workflows.  
-- **Cross-Platform Integration**: Access browser and operating system APIs seamlessly.  
-- **AI-Powered**: Harness the capabilities of AI systems like Claude 3.5, OpenAI for advanced automation.  
-- **Developer-Friendly**: Simplify complex tasks with an intuitive and flexible framework.  
+## Use Cases
 
----
+- Browser automation and web scraping
+- System file and process management
+- Workflow automation
+- Data processing and organization
+- GUI automation
+- Multi-step task orchestration
 
-## **Features**
+## Documentation
 
-- **Natural Language Programming**: Write code in plain English to interact with your system and browser.  
-- **Unified API Access**: A single interface for browser APIs, OS-level operations, and AI tools.  
-- **Event-Driven Automation**: Trigger workflows based on browser or system events.  
-- **Customizable Agents**: Build intelligent agents to perform repetitive or complex tasks.
-- **AI Integration**: Leverage advanced AI models to understand and execute complex commands.
+Visit our [documentation site](https://eko.fellou.ai/docs) for:
 
----
+- Getting started guide
+- API reference
+- Usage examples
+- Best practices
+- Configuration options
 
-## **Installation**
+## Development Environments
 
-### **Using npm**
+Eko can be used in multiple environments:
 
-```bash
-npm install @eko-ai/eko
-```
+- Browser Extension
+- Web Applications
+- Node.js Applications
+- [Fellou AI Browser](https://fellou.ai)
+
+## Community and Support
+
+- Report issues on [GitHub Issues](https://github.com/FellouAI/eko/issues)
+- Contribute tools and improvements
+- Share your use cases and feedback
+- Join our community discussions
 
 ## Contributing
 
-Contributions are welcome! Please follow these steps to contribute:
+We welcome contributions! See our [Contributing Guide](CONTRIBUTING.md) for details on:
 
-1. Fork the repository.
-2. Create a new branch: git checkout -b feature/- your-feature-name.
-3. Make your changes and commit them: git commit -m 'Add some feature'.
-4. Push to the branch: git push origin feature/your-feature-name.
-5. Submit a pull request.
-6. For detailed guidelines, see CONTRIBUTING.md.
+- Setting up the development environment
+- Code style guidelines
+- Submission process
+- Tool development
+- Use case optimization
 
 ## License
-This project is licensed under the MIT License.
 
-## Acknowledgments
+Eko is released under the MIT License. See the [LICENSE](LICENSE) file for details.

package/dist/core/eko.d.ts

@@ -3,6 +3,7 @@ import { EkoConfig, EkoInvokeParam, Tool, Workflow, WorkflowCallback } from '../
  * Eko core
  */
 export declare class Eko {
+    static tools: Map<string, Tool<any, any>>;
     private llmProvider;
     private toolRegistry;
     constructor(config: EkoConfig);

package/dist/core/tool-registry.d.ts

@@ -3,7 +3,7 @@ import { ToolDefinition } from '../types/llm.types';
 export declare class ToolRegistry {
     private tools;
     registerTool(tool: Tool<any, any>): void;
-    unregisterTool(toolName: string): void;
+    unregisterTool(toolName: string): boolean;
     getTool(toolName: string): Tool<any, any>;
     hasTools(toolNames: string[]): boolean;
     getAllTools(): Tool<any, any>[];

package/dist/extension/script/build_dom_tree.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Get clickable elements on the page
+ *
+ * @param {*} doHighlightElements Is highlighted
+ * @param {*} includeAttributes [attr_names...]
+ * @returns { element_str, selector_map }
+ */
+declare function get_clickable_elements(doHighlightElements: any | undefined, includeAttributes: any): string;
+/**
+ * Remove highlight
+ */
+declare function remove_highlight(): void;
+declare function clickable_elements_to_string(element_tree: any, includeAttributes: any): string;
+declare function create_selector_map(element_tree: any): {};
+declare function parse_node(node_data: any, parent: any): {
+    tagName: any;
+    xpath: any;
+    highlightIndex: any;
+    attributes: any;
+    isVisible: any;
+    isInteractive: any;
+    isTopElement: any;
+    shadowRoot: any;
+    children: never[];
+    parent: any;
+} | {
+    text: any;
+    isVisible: any;
+    parent: any;
+} | undefined;
+declare function build_dom_tree(doHighlightElements: any): {
+    tagName: any;
+    attributes: {};
+    xpath: string | null;
+    children: never[];
+} | {
+    type: string;
+    text: any;
+    isVisible: boolean;
+} | null;

package/dist/extension/tools/index.d.ts

@@ -3,9 +3,8 @@ import { ElementClick } from './element_click';
 import { ExportFile } from './export_file';
 import { ExtractContent } from './extract_content';
 import { FindElementPosition } from './find_element_position';
-import { FormAutofill } from './form_autofill';
 import { OpenUrl } from './open_url';
 import { Screenshot } from './screenshot';
 import { TabManagement } from './tab_management';
 import { WebSearch } from './web_search';
-export { BrowserUse, ElementClick, ExportFile, ExtractContent, FindElementPosition, FormAutofill, OpenUrl, Screenshot, TabManagement, WebSearch, };
+export { BrowserUse, ElementClick, ExportFile, ExtractContent, FindElementPosition, OpenUrl, Screenshot, TabManagement, WebSearch, };

package/dist/extension.cjs.js

@@ -235,6 +235,177 @@ var utils = /*#__PURE__*/Object.freeze({
     waitForTabComplete: waitForTabComplete
 });
 
+function exportFile(filename, type, content) {
+    const blob = new Blob([content], { type: type });
+    const link = document.createElement('a');
+    link.href = URL.createObjectURL(blob);
+    link.download = filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(link.href);
+}
+function getDropdownOptions(xpath) {
+    const select = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)
+        .singleNodeValue;
+    if (!select) {
+        return null;
+    }
+    return {
+        options: Array.from(select.options).map((opt) => ({
+            index: opt.index,
+            text: opt.text.trim(),
+            value: opt.value,
+        })),
+        id: select.id,
+        name: select.name,
+    };
+}
+function selectDropdownOption(xpath, text) {
+    const select = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)
+        .singleNodeValue;
+    if (!select || select.tagName.toUpperCase() !== 'SELECT') {
+        return { success: false, error: 'Select not found or invalid element type' };
+    }
+    const option = Array.from(select.options).find((opt) => opt.text.trim() === text);
+    if (!option) {
+        return {
+            success: false,
+            error: 'Option not found',
+            availableOptions: Array.from(select.options).map((o) => o.text.trim()),
+        };
+    }
+    select.value = option.value;
+    select.dispatchEvent(new Event('change'));
+    return {
+        success: true,
+        selectedValue: option.value,
+        selectedText: option.text.trim(),
+    };
+}
+/**
+ * Extract the elements related to html operability and wrap them into pseudo-html code.
+ */
+function extractOperableElements() {
+    // visible
+    const isElementVisible = (element) => {
+        const style = window.getComputedStyle(element);
+        return (style.display !== 'none' &&
+            style.visibility !== 'hidden' &&
+            style.opacity !== '0' &&
+            element.offsetWidth > 0 &&
+            element.offsetHeight > 0);
+    };
+    // element original index
+    const getElementIndex = (element) => {
+        const xpath = document.evaluate('preceding::*', element, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+        return xpath.snapshotLength;
+    };
+    // exclude
+    const addExclude = (excludes, children) => {
+        for (let i = 0; i < children.length; i++) {
+            excludes.push(children[i]);
+            if (children[i].children) {
+                addExclude(excludes, children[i].children);
+            }
+        }
+    };
+    // { pseudoId: element }
+    let elementMap = {};
+    let nextId = 1;
+    let elements = [];
+    let excludes = [];
+    // operable element
+    const operableSelectors = 'a, button, input, textarea, select';
+    document.querySelectorAll(operableSelectors).forEach((element) => {
+        if (isElementVisible(element) && excludes.indexOf(element) == -1) {
+            const id = nextId++;
+            elementMap[id.toString()] = element;
+            const tagName = element.tagName.toLowerCase();
+            const attributes = Array.from(element.attributes)
+                .filter((attr) => ['id', 'name', 'type', 'value', 'href', 'title', 'placeholder'].includes(attr.name))
+                .map((attr) => `${attr.name == 'id' ? 'target' : attr.name}="${attr.value}"`)
+                .join(' ');
+            elements.push({
+                originalIndex: getElementIndex(element),
+                id: id,
+                html: `<${tagName} id="${id}" ${attributes}>${tagName == 'select' ? element.innerHTML : element.innerText || ''}</${tagName}>`,
+            });
+            addExclude(excludes, element.children);
+        }
+    });
+    // short text element
+    const textWalker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT, {
+        acceptNode: function (node) {
+            var _a;
+            if (node.matches(operableSelectors) || excludes.indexOf(node) != -1) {
+                // skip
+                return NodeFilter.FILTER_SKIP;
+            }
+            // text <= 100
+            const text = (_a = node.innerText) === null || _a === void 0 ? void 0 : _a.trim();
+            if (isElementVisible(node) &&
+                text &&
+                text.length <= 100 &&
+                text.length > 0 &&
+                node.children.length === 0) {
+                return NodeFilter.FILTER_ACCEPT;
+            }
+            // skip
+            return NodeFilter.FILTER_SKIP;
+        },
+    });
+    let currentNode;
+    while ((currentNode = textWalker.nextNode())) {
+        const id = nextId++;
+        elementMap[id.toString()] = currentNode;
+        const tagName = currentNode.tagName.toLowerCase();
+        elements.push({
+            originalIndex: getElementIndex(currentNode),
+            id: id,
+            html: `<${tagName} id="${id}">${currentNode.innerText.trim()}</${tagName}>`,
+        });
+    }
+    // element sort
+    elements.sort((a, b) => a.originalIndex - b.originalIndex);
+    // cache
+    window.operableElementMap = elementMap;
+    // pseudo html
+    return elements.map((e) => e.html).join('\n');
+}
+function clickOperableElement(id) {
+    let element = window.operableElementMap[id];
+    if (!element) {
+        return false;
+    }
+    if (element.click) {
+        element.click();
+    }
+    else {
+        element.dispatchEvent(new MouseEvent('click', {
+            view: window,
+            bubbles: true,
+            cancelable: true,
+        }));
+    }
+    return true;
+}
+function getOperableElementRect(id) {
+    let element = window.operableElementMap[id];
+    if (!element) {
+        return null;
+    }
+    const rect = element.getBoundingClientRect();
+    return {
+        left: rect.left + window.scrollX,
+        top: rect.top + window.scrollY,
+        right: rect.right + window.scrollX,
+        bottom: rect.bottom + window.scrollY,
+        width: rect.right - rect.left,
+        height: rect.bottom - rect.top,
+    };
+}
+
 async function key(tabId, key, coordinate) {
     if (!coordinate) {
         coordinate = (await cursor_position(tabId)).coordinate;
@@ -444,177 +615,6 @@ var browser = /*#__PURE__*/Object.freeze({
     type_by_xpath: type_by_xpath
 });
 
-function exportFile(filename, type, content) {
-    const blob = new Blob([content], { type: type });
-    const link = document.createElement('a');
-    link.href = URL.createObjectURL(blob);
-    link.download = filename;
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    URL.revokeObjectURL(link.href);
-}
-function getDropdownOptions(xpath) {
-    const select = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)
-        .singleNodeValue;
-    if (!select) {
-        return null;
-    }
-    return {
-        options: Array.from(select.options).map((opt) => ({
-            index: opt.index,
-            text: opt.text.trim(),
-            value: opt.value,
-        })),
-        id: select.id,
-        name: select.name,
-    };
-}
-function selectDropdownOption(xpath, text) {
-    const select = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)
-        .singleNodeValue;
-    if (!select || select.tagName.toUpperCase() !== 'SELECT') {
-        return { success: false, error: 'Select not found or invalid element type' };
-    }
-    const option = Array.from(select.options).find((opt) => opt.text.trim() === text);
-    if (!option) {
-        return {
-            success: false,
-            error: 'Option not found',
-            availableOptions: Array.from(select.options).map((o) => o.text.trim()),
-        };
-    }
-    select.value = option.value;
-    select.dispatchEvent(new Event('change'));
-    return {
-        success: true,
-        selectedValue: option.value,
-        selectedText: option.text.trim(),
-    };
-}
-/**
- * Extract the elements related to html operability and wrap them into pseudo-html code.
- */
-function extractOperableElements() {
-    // visible
-    const isElementVisible = (element) => {
-        const style = window.getComputedStyle(element);
-        return (style.display !== 'none' &&
-            style.visibility !== 'hidden' &&
-            style.opacity !== '0' &&
-            element.offsetWidth > 0 &&
-            element.offsetHeight > 0);
-    };
-    // element original index
-    const getElementIndex = (element) => {
-        const xpath = document.evaluate('preceding::*', element, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-        return xpath.snapshotLength;
-    };
-    // exclude
-    const addExclude = (excludes, children) => {
-        for (let i = 0; i < children.length; i++) {
-            excludes.push(children[i]);
-            if (children[i].children) {
-                addExclude(excludes, children[i].children);
-            }
-        }
-    };
-    // { pseudoId: element }
-    let elementMap = {};
-    let nextId = 1;
-    let elements = [];
-    let excludes = [];
-    // operable element
-    const operableSelectors = 'a, button, input, textarea, select';
-    document.querySelectorAll(operableSelectors).forEach((element) => {
-        if (isElementVisible(element) && excludes.indexOf(element) == -1) {
-            const id = nextId++;
-            elementMap[id.toString()] = element;
-            const tagName = element.tagName.toLowerCase();
-            const attributes = Array.from(element.attributes)
-                .filter((attr) => ['id', 'name', 'type', 'value', 'href', 'title', 'placeholder'].includes(attr.name))
-                .map((attr) => `${attr.name == 'id' ? 'target' : attr.name}="${attr.value}"`)
-                .join(' ');
-            elements.push({
-                originalIndex: getElementIndex(element),
-                id: id,
-                html: `<${tagName} id="${id}" ${attributes}>${tagName == 'select' ? element.innerHTML : element.innerText || ''}</${tagName}>`,
-            });
-            addExclude(excludes, element.children);
-        }
-    });
-    // short text element
-    const textWalker = document.createTreeWalker(document.body, NodeFilter.SHOW_ELEMENT, {
-        acceptNode: function (node) {
-            var _a;
-            if (node.matches(operableSelectors) || excludes.indexOf(node) != -1) {
-                // skip
-                return NodeFilter.FILTER_SKIP;
-            }
-            // text <= 100
-            const text = (_a = node.innerText) === null || _a === void 0 ? void 0 : _a.trim();
-            if (isElementVisible(node) &&
-                text &&
-                text.length <= 100 &&
-                text.length > 0 &&
-                node.children.length === 0) {
-                return NodeFilter.FILTER_ACCEPT;
-            }
-            // skip
-            return NodeFilter.FILTER_SKIP;
-        },
-    });
-    let currentNode;
-    while ((currentNode = textWalker.nextNode())) {
-        const id = nextId++;
-        elementMap[id.toString()] = currentNode;
-        const tagName = currentNode.tagName.toLowerCase();
-        elements.push({
-            originalIndex: getElementIndex(currentNode),
-            id: id,
-            html: `<${tagName} id="${id}">${currentNode.innerText.trim()}</${tagName}>`,
-        });
-    }
-    // element sort
-    elements.sort((a, b) => a.originalIndex - b.originalIndex);
-    // cache
-    window.operableElementMap = elementMap;
-    // pseudo html
-    return elements.map((e) => e.html).join('\n');
-}
-function clickOperableElement(id) {
-    let element = window.operableElementMap[id];
-    if (!element) {
-        return false;
-    }
-    if (element.click) {
-        element.click();
-    }
-    else {
-        element.dispatchEvent(new MouseEvent('click', {
-            view: window,
-            bubbles: true,
-            cancelable: true,
-        }));
-    }
-    return true;
-}
-function getOperableElementRect(id) {
-    let element = window.operableElementMap[id];
-    if (!element) {
-        return null;
-    }
-    const rect = element.getBoundingClientRect();
-    return {
-        left: rect.left + window.scrollX,
-        top: rect.top + window.scrollY,
-        right: rect.right + window.scrollX,
-        bottom: rect.bottom + window.scrollY,
-        width: rect.right - rect.left,
-        height: rect.bottom - rect.top,
-    };
-}
-
 /**
  * Browser Use for general
  */
@@ -1185,24 +1185,6 @@ async function executeWithBrowserUse(context, task_prompt) {
     };
 }
 
-/**
- * Form Autofill
- */
-class FormAutofill {
-    constructor() {
-        this.name = 'form_autofill';
-        this.description = 'Automatically fill in form data on web pages';
-        this.input_schema = {
-            type: 'object',
-            properties: {}
-        };
-    }
-    async execute(context, params) {
-        // form -> input, textarea, select ...
-        throw new Error('Not implemented');
-    }
-}
-
 /**
  * Open Url
  */
@@ -1740,7 +1722,6 @@ var tools = /*#__PURE__*/Object.freeze({
     ExportFile: ExportFile,
     ExtractContent: ExtractContent,
     FindElementPosition: FindElementPosition,
-    FormAutofill: FormAutofill,
     OpenUrl: OpenUrl,
     Screenshot: Screenshot,
     TabManagement: TabManagement,