kinenix 0.1.0b1__tar.gz

kinenix-0.1.0b1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 arttopix / Kinenix
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kinenix-0.1.0b1/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: kinenix
+Version: 0.1.0b1
+Summary: Core execution engine and standard action libraries for Kinenix RPA platform
+Author: arttopix
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/arttopix/Kinenix
+Project-URL: Documentation, https://github.com/arttopix/Kinenix/tree/main/docs
+Project-URL: Issues, https://github.com/arttopix/Kinenix/issues
+Keywords: rpa,automation,playwright,workflow,local-ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: playwright>=1.40.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# kinenix
+
+Core execution engine and `kinenix` CLI for **Kinenix**, an open-source, local AI-native RPA framework in Python.
+
+> **Status: beta.** Flow schemas and action parameters may still change between releases.
+
+- Runs automation flows written as `flow.json` or `flow.md`
+- Built-in actions for web automation (Playwright), Excel and CSV (no Microsoft Office required), files, HTTP, email, and flow control
+- Local AI actions through Ollama, so business data stays on your machine
+- Retries, fallbacks, failure screenshots, and structured JSON execution logs
+
+## Installation
+
+```bash
+pip install kinenix
+kinenix install-browsers   # Playwright Chromium, needed for web actions
+kinenix --version
+```
+
+Requires Python 3.10 or newer.
+
+## Usage
+
+```bash
+kinenix list                       # list flows found in the current project
+kinenix run path/to/flow.json      # run a flow
+kinenix compile path/to/flow.md    # compile flow.md into flow.json
+kinenix version                    # version and environment details
+```
+
+## Related packages
+
+The worker, Studio, and Orchestrator modules live in the same repository and are not yet published on PyPI.
+
+## Documentation
+
+- [Project README](https://github.com/arttopix/Kinenix#readme)
+- [Actions reference](https://github.com/arttopix/Kinenix/blob/main/docs/actions_reference.md)
+- [Flow Markdown specification](https://github.com/arttopix/Kinenix/blob/main/docs/flow_markdown_spec.md)
+- [CLI guide](https://github.com/arttopix/Kinenix/blob/main/docs/cli_guide.md)
+
+## License
+
+MIT

kinenix-0.1.0b1/README.md

@@ -0,0 +1,44 @@
+# kinenix
+
+Core execution engine and `kinenix` CLI for **Kinenix**, an open-source, local AI-native RPA framework in Python.
+
+> **Status: beta.** Flow schemas and action parameters may still change between releases.
+
+- Runs automation flows written as `flow.json` or `flow.md`
+- Built-in actions for web automation (Playwright), Excel and CSV (no Microsoft Office required), files, HTTP, email, and flow control
+- Local AI actions through Ollama, so business data stays on your machine
+- Retries, fallbacks, failure screenshots, and structured JSON execution logs
+
+## Installation
+
+```bash
+pip install kinenix
+kinenix install-browsers   # Playwright Chromium, needed for web actions
+kinenix --version
+```
+
+Requires Python 3.10 or newer.
+
+## Usage
+
+```bash
+kinenix list                       # list flows found in the current project
+kinenix run path/to/flow.json      # run a flow
+kinenix compile path/to/flow.md    # compile flow.md into flow.json
+kinenix version                    # version and environment details
+```
+
+## Related packages
+
+The worker, Studio, and Orchestrator modules live in the same repository and are not yet published on PyPI.
+
+## Documentation
+
+- [Project README](https://github.com/arttopix/Kinenix#readme)
+- [Actions reference](https://github.com/arttopix/Kinenix/blob/main/docs/actions_reference.md)
+- [Flow Markdown specification](https://github.com/arttopix/Kinenix/blob/main/docs/flow_markdown_spec.md)
+- [CLI guide](https://github.com/arttopix/Kinenix/blob/main/docs/cli_guide.md)
+
+## License
+
+MIT

kinenix-0.1.0b1/kinenix/__init__.py

@@ -0,0 +1,5 @@
+"""
+kinenix-core: Core Execution Engine for Kinenix RPA Platform
+"""
+
+__version__ = "0.1.0b1"

kinenix-0.1.0b1/kinenix/actions/__init__.py

@@ -0,0 +1,23 @@
+"""
+Actions registry and standard action implementations.
+"""
+
+from .base import BaseAction
+from .registry import ActionRegistry, register_action
+from . import logic, data_excel, web_playwright, http_api, flow_control, email_smtp, ai_ollama, file_system, ai_systemone
+
+__all__ = [
+    "BaseAction",
+    "ActionRegistry",
+    "register_action",
+    "logic",
+    "data_excel",
+    "web_playwright",
+    "http_api",
+    "flow_control",
+    "email_smtp",
+    "ai_ollama",
+    "file_system",
+    "ai_systemone",
+]
+

kinenix-0.1.0b1/kinenix/actions/ai_ollama.py

@@ -0,0 +1,156 @@
+import base64
+import json
+import logging
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+import requests
+
+from .base import BaseAction
+from .registry import register_action
+from ..models.context import ExecutionContext
+
+logger = logging.getLogger("kinenix")
+
+
+def _resolve_file_path(file_path: str, context: ExecutionContext) -> Path:
+    target_path = Path(file_path)
+    if not target_path.is_absolute():
+        flow_dir_str = context.get_variable("__flow_dir__")
+        if flow_dir_str:
+            target_path = Path(flow_dir_str) / file_path
+    return target_path
+
+
+def _clean_json_text(text: str) -> str:
+    """
+    Strips markdown code fences (e.g. ```json ... ```) from LLM output.
+    """
+    stripped = text.strip()
+    match = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", stripped, re.IGNORECASE)
+    if match:
+        return match.group(1).strip()
+    return stripped
+
+
+@register_action("ai.prompt")
+class OllamaPromptAction(BaseAction):
+    """
+    Executes a prompt against a local Ollama service.
+    Supports structured JSON enforcement and image inputs (multimodal).
+    """
+
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        prompt = str(parameters.get("prompt", "")).strip()
+        system = parameters.get("system")
+        model = str(parameters.get("model", "qwen2.5:1.5b"))
+        output_format = parameters.get("format")
+        base_url = str(parameters.get("base_url", "http://localhost:11434")).rstrip("/")
+        timeout = float(parameters.get("timeout", 60))
+        temperature = float(parameters.get("temperature", 0.1))
+
+        if not prompt:
+            raise ValueError("Parameter 'prompt' is required for action 'ai.prompt'.")
+
+        payload: Dict[str, Any] = {
+            "model": model,
+            "prompt": prompt,
+            "stream": False,
+            "options": {
+                "temperature": temperature
+            }
+        }
+
+        if system:
+            payload["system"] = str(system)
+
+        if output_format:
+            payload["format"] = output_format
+
+        # Handle optional image path for multimodal / vision models
+        image_path_str = parameters.get("image_path")
+        if image_path_str:
+            target_image = _resolve_file_path(image_path_str, context)
+            if not target_image.is_file():
+                raise FileNotFoundError(f"Image file not found: {image_path_str}")
+            with open(target_image, "rb") as img_f:
+                b64_img = base64.b64encode(img_f.read()).decode("utf-8")
+            payload["images"] = [b64_img]
+
+        endpoint = f"{base_url}/api/generate"
+
+        try:
+            response = requests.post(endpoint, json=payload, timeout=timeout)
+            response.raise_for_status()
+            data = response.json()
+        except requests.exceptions.ConnectionError as conn_err:
+            raise ConnectionError(
+                f"Failed to connect to Ollama service at '{endpoint}'. "
+                "Ensure Ollama is running (e.g. 'ollama serve' or running in the background)."
+            ) from conn_err
+        except Exception as req_err:
+            raise RuntimeError(f"Ollama API request error: {req_err}") from req_err
+
+        raw_response = data.get("response", "")
+        parsed_output: Any = raw_response
+
+        if output_format == "json":
+            cleaned = _clean_json_text(raw_response)
+            try:
+                parsed_output = json.loads(cleaned)
+            except Exception as json_err:
+                logger.warning(f"Could not parse Ollama response as JSON: {json_err}. Returning raw text.")
+                parsed_output = raw_response
+
+        return {
+            "response": parsed_output,
+            "raw_text": raw_response,
+            "model": model,
+            "total_duration": data.get("total_duration")
+        }
+
+
+@register_action("ai.extract")
+class OllamaExtractAction(BaseAction):
+    """
+    Extracts structured data entities from text or an image using Ollama.
+    """
+
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        schema: Optional[Any] = parameters.get("schema")
+        instructions = parameters.get("instructions", "Extract all key invoice fields into JSON.")
+        text = parameters.get("text", "")
+        image_path_str = parameters.get("image_path")
+        model = str(parameters.get("model", "qwen2.5:1.5b"))
+        base_url = str(parameters.get("base_url", "http://localhost:11434")).rstrip("/")
+        timeout = float(parameters.get("timeout", 90))
+
+        prompt_parts: List[str] = [str(instructions)]
+
+        if schema:
+            prompt_parts.append(
+                f"Required JSON schema or fields: {json.dumps(schema) if isinstance(schema, (dict, list)) else schema}"
+            )
+
+        prompt_parts.append("Respond strictly with a valid JSON object. Do not include explanatory conversational text.")
+
+        if text:
+            prompt_parts.append(f"Content to extract from:\n{text}")
+
+        prompt = "\n\n".join(prompt_parts)
+
+        action = OllamaPromptAction()
+        action_params = {
+            "prompt": prompt,
+            "model": model,
+            "format": "json",
+            "base_url": base_url,
+            "timeout": timeout,
+            "temperature": 0.0
+        }
+
+        if image_path_str:
+            action_params["image_path"] = image_path_str
+
+        result = action.execute(action_params, context)
+        return result.get("response")

kinenix-0.1.0b1/kinenix/actions/ai_systemone.py

@@ -0,0 +1,201 @@
+import json
+import logging
+from typing import Any, Dict, List, Optional, Union
+import requests
+
+from .base import BaseAction
+from .registry import register_action
+from ..models.context import ExecutionContext
+
+logger = logging.getLogger("kinenix.ai_systemone")
+
+
+def call_systemone_api(
+    state: Union[str, Dict[str, Any]],
+    questions: Dict[str, Any],
+    base_url: str = "http://localhost:8000",
+    timeout: float = 30.0,
+    fallback_to_ollama: bool = False
+) -> Dict[str, Any]:
+    """
+    Sends a structured decision request to a local or remote OpenThai-SystemOne API server.
+    Converts friendly parameter formats (e.g. options list) to the model's required format.
+    """
+    clean_url = str(base_url).rstrip("/")
+    endpoint = f"{clean_url}/v1/systemone"
+
+    # Normalize state to string if dict or primitive
+    normalized_state: str = state if isinstance(state, str) else json.dumps(state, ensure_ascii=False)
+
+    # Normalize questions payload
+    normalized_questions: Dict[str, Any] = {}
+    for q_key, q_val in questions.items():
+        if not isinstance(q_val, dict):
+            continue
+
+        q_type = str(q_val.get("type", "choice")).lower()
+        instructions = q_val.get("instructions") or q_val.get("instruction") or f"Select the best match for {q_key}"
+        criteria = q_val.get("criteria")
+
+        if criteria is None:
+            # Convert list of options to criteria dict (option -> None)
+            options_list = q_val.get("options") or []
+            if isinstance(options_list, list):
+                criteria = {str(opt): None for opt in options_list}
+            elif isinstance(options_list, dict):
+                criteria = options_list
+            else:
+                criteria = {}
+
+        if q_type == "choice":
+            normalized_questions[q_key] = {
+                "type": "choice",
+                "instructions": instructions,
+                "criteria": criteria
+            }
+        elif q_type == "score":
+            normalized_questions[q_key] = {
+                "type": "score",
+                "instructions": instructions,
+                "criteria": criteria or {"1": "low", "2": "medium", "3": "high"}
+            }
+        elif q_type in ("noul", "yes_no", "boolean"):
+            normalized_questions[q_key] = {
+                "type": "noul",
+                "instructions": instructions
+            }
+        else:
+            normalized_questions[q_key] = q_val
+
+    payload = {
+        "state": normalized_state,
+        "questions": normalized_questions
+    }
+
+    try:
+        response = requests.post(
+            endpoint,
+            json=payload,
+            headers={"Content-Type": "application/json; charset=utf-8"},
+            timeout=timeout
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.ConnectionError as conn_err:
+        if fallback_to_ollama:
+            logger.warning(
+                f"OpenThai-SystemOne server at '{endpoint}' unreachable. Attempting fallback to local Ollama..."
+            )
+            return _fallback_ollama_decision(normalized_state, normalized_questions, timeout=timeout)
+        raise ConnectionError(
+            f"Failed to connect to OpenThai-SystemOne server at '{endpoint}'. "
+            "Ensure the server is running (e.g. '$env:OPENTHAI_SYSTEMONE_MODEL=\"iapp/OpenThai-SystemOne\"; uvicorn openthai_systemone.server:app --port 8000')."
+        ) from conn_err
+    except Exception as e:
+        raise RuntimeError(f"OpenThai-SystemOne request error: {e}") from e
+
+
+def _fallback_ollama_decision(state: str, questions: Dict[str, Any], timeout: float = 60.0) -> Dict[str, Any]:
+    """
+    Fallback resolver using Ollama if OpenThai-SystemOne server is offline.
+    """
+    ollama_url = "http://localhost:11434/api/generate"
+    answers = {}
+
+    for q_key, q_val in questions.items():
+        q_type = q_val.get("type", "choice")
+        instructions = q_val.get("instructions", "")
+        criteria = q_val.get("criteria", {})
+        options = list(criteria.keys())
+
+        prompt = (
+            f"Context: {state}\n"
+            f"Question: {instructions}\n"
+            f"Options: {json.dumps(options, ensure_ascii=False)}\n"
+            f"Return JSON: {{\"choice\": \"<selected option>\"}}"
+        )
+
+        try:
+            res = requests.post(
+                ollama_url,
+                json={"model": "qwen2.5:1.5b", "prompt": prompt, "format": "json", "stream": False},
+                timeout=timeout
+            )
+            res.raise_for_status()
+            res_data = res.json()
+            parsed = json.loads(res_data.get("response", "{}"))
+            answers[q_key] = {
+                "type": q_type,
+                "choice": parsed.get("choice") or (options[0] if options else None),
+                "confidence": 0.5,
+                "fallback": "ollama"
+            }
+        except Exception as ex:
+            logger.warning(f"Ollama fallback failed for question '{q_key}': {ex}")
+            answers[q_key] = {
+                "type": q_type,
+                "choice": options[0] if options else None,
+                "confidence": 0.0,
+                "error": str(ex)
+            }
+
+    return {"model": "ollama-fallback", "answers": answers, "usage": {"input_tokens": 0, "output_tokens": 0}}
+
+
+@register_action("ai.decide")
+class AiDecideAction(BaseAction):
+    """
+    Executes fast semantic decisions (Choice, Score, Yes/No) using OpenThai-SystemOne (0.8B).
+    Computes calibrated probabilities in a single forward pass without text generation hallucination.
+    """
+
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        state = parameters.get("state")
+        if state is None:
+            raise ValueError("Parameter 'state' is required for action 'ai.decide'.")
+
+        base_url = str(parameters.get("base_url", "http://localhost:8000"))
+        timeout = float(parameters.get("timeout", 30.0))
+        fallback_to_ollama = bool(parameters.get("fallback_to_ollama", True))
+
+        # Accept either 'question' (singular) or 'questions' (plural dictionary)
+        single_question = parameters.get("question")
+        questions_dict = parameters.get("questions")
+
+        if single_question and isinstance(single_question, dict):
+            q_name = single_question.get("name", "decision")
+            questions = {q_name: single_question}
+            is_single = True
+        elif questions_dict and isinstance(questions_dict, dict):
+            questions = questions_dict
+            is_single = False
+        else:
+            raise ValueError("Either 'question' (dict) or 'questions' (dict) parameter is required for 'ai.decide'.")
+
+        response = call_systemone_api(
+            state=state,
+            questions=questions,
+            base_url=base_url,
+            timeout=timeout,
+            fallback_to_ollama=fallback_to_ollama
+        )
+
+        answers = response.get("answers", {})
+
+        if is_single and len(answers) == 1:
+            # For convenient single-question calls, unwrap the direct answer
+            single_res = list(answers.values())[0]
+            return {
+                "choice": single_res.get("choice"),
+                "confidence": single_res.get("confidence"),
+                "probabilities": single_res.get("probabilities", {}),
+                "type": single_res.get("type"),
+                "model": response.get("model", "openthai-systemone")
+            }
+
+        return {
+            "answers": answers,
+            "model": response.get("model", "openthai-systemone"),
+            "usage": response.get("usage", {})
+        }
+

kinenix-0.1.0b1/kinenix/actions/base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+from ..models.context import ExecutionContext
+
+
+class BaseAction(ABC):
+    """
+    Abstract base class for all Kinenix Actions.
+    """
+
+    action_type: str = "base"
+
+    @abstractmethod
+    def execute(self, parameters: Dict[str, Any], context: ExecutionContext) -> Any:
+        """
+        Executes the action with given parameters and context.
+        Returns output data to be stored or used by downstream steps.
+        """
+        pass