termux-aichain 1.0.0__tar.gz

termux_aichain-1.0.0/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 UnoKim & AMEVA Open-Source Foundation
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

termux_aichain-1.0.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: termux-aichain
+Version: 1.0.0
+Summary: Sovereign Zero-Dependency AI Chaining and Multimodal Autonomous Agent Framework for Android Edge and Termux
+Home-page: https://github.com/uno-km/termux-aichain
+Author: UnoKim
+Author-email: UnoKim <uno-km@users.noreply.github.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/uno-km/termux-aichain
+Project-URL: Repository, https://github.com/uno-km/termux-aichain.git
+Project-URL: Issues, https://github.com/uno-km/termux-aichain/issues
+Keywords: termux,android,edge-ai,langchain,llama-cpp,bitnet,agent,zero-dependency
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Android
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python

termux_aichain-1.0.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "termux-aichain"
+version = "1.0.0"
+description = "Sovereign Zero-Dependency AI Chaining and Multimodal Autonomous Agent Framework for Android Edge and Termux"
+readme = "README.md"
+authors = [{ name = "UnoKim", email = "uno-km@users.noreply.github.com" }]
+license = { text = "Apache-2.0" }
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Android",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+keywords = ["termux", "android", "edge-ai", "langchain", "llama-cpp", "bitnet", "agent", "zero-dependency"]
+requires-python = ">=3.10"
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/uno-km/termux-aichain"
+Repository = "https://github.com/uno-km/termux-aichain.git"
+Issues = "https://github.com/uno-km/termux-aichain/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["termux_aichain*"]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+testpaths = ["tests"]
+[project.scripts]
+termux-aichain = "termux_aichain.cli:main"

termux_aichain-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

termux_aichain-1.0.0/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="termux-aichain",
+    version="0.1.0",
+    description="Ultra-lightweight Zero-Dependency AI chaining & agent framework for Termux, Android and Edge computing.",
+    long_description=open("README.md", encoding="utf-8").read() if open("README.md", encoding="utf-8") else "",
+    long_description_content_type="text/markdown",
+    author="UnoKim",
+    author_email="uno-km@users.noreply.github.com",
+    url="https://github.com/uno-km/termux-aichain",
+    packages=find_packages(),
+    python_requires=">=3.10",
+    install_requires=[],
+    classifiers=[
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: Android",
+        "Operating System :: POSIX :: Linux",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+    ],
+)

termux_aichain-1.0.0/termux_aichain/__init__.py

@@ -0,0 +1,149 @@
+"""
+==============================================================================
+termux-aichain: Sovereign Zero-Dependency Edge AI Framework for Termux & Android
+==============================================================================
+Copyright (c) 2026 AMEVA Open-Source Foundation & UnoKim.
+Licensed under the Apache License, Version 2.0.
+"""
+
+__version__ = "1.0.0"
+__author__ = "UnoKim <uno-km@users.noreply.github.com>"
+
+from termux_aichain.core.schema import (
+    Message,
+    HumanMessage,
+    AIMessage,
+    SystemMessage,
+    ToolMessage,
+    UsageInfo,
+    GenerationResult,
+    StreamChunk,
+)
+from termux_aichain.core.prompt import (
+    PromptTemplate,
+    ChatPromptTemplate,
+)
+from termux_aichain.core.base import (
+    Runnable,
+    RunnableLambda,
+    RunnableSequence,
+    BaseChatModel,
+)
+from termux_aichain.core.providers.openai_compatible import OpenAICompatibleChat
+from termux_aichain.core.providers.bitnet import BitNetChat
+from termux_aichain.core.providers.local_server import (
+    LocalServerConfig,
+    LocalServerManager,
+    LlamaCppServer,
+    BitNetServer,
+)
+from termux_aichain.core.parsers import (
+    StringOutputParser,
+    JsonOutputParser,
+    RegexOutputParser,
+)
+from termux_aichain.core.splitters import (
+    Document,
+    CharacterTextSplitter,
+    RecursiveCharacterTextSplitter,
+    TextLoader,
+    MarkdownLoader,
+    JSONLoader,
+)
+from termux_aichain.graph.state import (
+    StateGraph,
+    CompiledGraph,
+    START,
+    END,
+)
+from termux_aichain.graph.agent import (
+    Tool,
+    tool,
+    create_react_agent,
+)
+from termux_aichain.memory.buffer import ConversationBufferMemory
+from termux_aichain.memory.sqlite import SQLiteEntityMemory, SQLiteVectorStore
+from termux_aichain.memory.extractor import FactExtractor
+from termux_aichain.serve.server import AgentServer, serve
+from termux_aichain.serve.dashboard import DASHBOARD_HTML
+from termux_aichain.trace.tracer import TraceSpan, Tracer, traceable
+from termux_aichain.device.tools import (
+    get_battery_status,
+    get_sensor_data,
+    get_device_location,
+    record_speech_to_text,
+    vibrate_device,
+    send_notification,
+    speak_tts,
+    execute_shell,
+    get_default_device_tools,
+)
+from termux_aichain.device.ecosystem import (
+    transcribe_speech,
+    generate_diffusion_image,
+    browse_web_headless,
+    get_ecosystem_tools,
+)
+
+__all__ = [
+    "__version__",
+    "Message",
+    "HumanMessage",
+    "AIMessage",
+    "SystemMessage",
+    "ToolMessage",
+    "UsageInfo",
+    "GenerationResult",
+    "StreamChunk",
+    "PromptTemplate",
+    "ChatPromptTemplate",
+    "Runnable",
+    "RunnableLambda",
+    "RunnableSequence",
+    "BaseChatModel",
+    "OpenAICompatibleChat",
+    "BitNetChat",
+    "LocalServerConfig",
+    "LocalServerManager",
+    "LlamaCppServer",
+    "BitNetServer",
+    "StringOutputParser",
+    "JsonOutputParser",
+    "RegexOutputParser",
+    "Document",
+    "CharacterTextSplitter",
+    "RecursiveCharacterTextSplitter",
+    "TextLoader",
+    "MarkdownLoader",
+    "JSONLoader",
+    "StateGraph",
+    "CompiledGraph",
+    "START",
+    "END",
+    "Tool",
+    "tool",
+    "create_react_agent",
+    "ConversationBufferMemory",
+    "SQLiteEntityMemory",
+    "SQLiteVectorStore",
+    "FactExtractor",
+    "AgentServer",
+    "serve",
+    "DASHBOARD_HTML",
+    "TraceSpan",
+    "Tracer",
+    "traceable",
+    "get_battery_status",
+    "get_sensor_data",
+    "get_device_location",
+    "record_speech_to_text",
+    "vibrate_device",
+    "send_notification",
+    "speak_tts",
+    "execute_shell",
+    "get_default_device_tools",
+    "transcribe_speech",
+    "generate_diffusion_image",
+    "browse_web_headless",
+    "get_ecosystem_tools",
+]

termux_aichain-1.0.0/termux_aichain/cli.py

@@ -0,0 +1,128 @@
+"""
+==============================================================================
+termux-aichain Unified Command Line Interface & One-Touch Provisioner
+==============================================================================
+Provides sovereign zero-state setup, environment diagnostics, model pull,
+and 1-line serving CLI for Android Termux.
+Zero external heavy dependencies - Pure Python 3.10+ standard library.
+"""
+
+from __future__ import annotations
+import os
+import sys
+import shutil
+import argparse
+import subprocess
+import urllib.request
+from termux_aichain import __version__, serve, PromptTemplate, LocalServerConfig, LlamaCppServer
+
+MODELS_REGISTRY = {
+    "llama-3.2-3b": {
+        "url": "https://huggingface.co/bartowski/Llama-3.2-3B-Instruct-GGUF/resolve/main/Llama-3.2-3B-Instruct-Q4_K_M.gguf",
+        "filename": "Llama-3.2-3B-Instruct-Q4_K_M.gguf",
+        "size_desc": "~1.9 GB",
+    },
+    "qwen-2.5-1.5b": {
+        "url": "https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct-GGUF/resolve/main/qwen2.5-1.5b-instruct-q4_k_m.gguf",
+        "filename": "qwen2.5-1.5b-instruct-q4_k_m.gguf",
+        "size_desc": "~0.98 GB",
+    },
+    "bitnet-3b": {
+        "url": "https://huggingface.co/1bitLLM/bitnet_b1_58-3B-GGUF/resolve/main/bitnet_b1_58-3B-Q4_K_M.gguf",
+        "filename": "bitnet_b1_58-3B-Q4_K_M.gguf",
+        "size_desc": "~1.8 GB",
+    }
+}
+
+def cmd_setup() -> None:
+    """Diagnoses environment and provisions required native tools."""
+    print("=" * 70)
+    print(f"⚡ termux-aichain v{__version__} One-Touch Environment Diagnostics")
+    print("=" * 70)
+    
+    is_termux = "com.termux" in os.environ.get("PREFIX", "") or os.path.exists("/data/data/com.termux")
+    print(f"• Platform Environment : {'Android Termux (Native)' if is_termux else 'Host OS'}")
+    print(f"• Python Version       : {sys.version.split()[0]}")
+    
+    # Check Termux:API
+    has_api = bool(shutil.which("termux-battery-status"))
+    print(f"• Termux-API CLI Tools : {'[OK] Installed' if has_api else '[WARN] Not Installed (Using Kernel Sysfs Fallback)'}")
+    
+    # Check llama-server
+    has_llama = bool(shutil.which("llama-server"))
+    print(f"• Local llama-server   : {'[OK] Available' if has_llama else '[OPTIONAL] Not in PATH (Can use external/bitnet endpoint)'}")
+    
+    # Check Node.js
+    has_node = bool(shutil.which("node"))
+    print(f"• Node.js ESM Runtime  : {'[OK] ' + subprocess.check_output(['node', '-v'], text=True).strip() if has_node else '[INFO] Node.js not detected'}")
+
+    print("-" * 70)
+    if is_termux and not has_api:
+        print("[*] To enable full hardware sensors/vibration on Termux, run:")
+        print("    pkg update && pkg install termux-api -y\n")
+    print("[+] All Core, Graph, Memory, Serve, and Trace modules are 100% ready!")
+    print("=" * 70)
+
+def cmd_pull(model_name: str) -> None:
+    """Downloads validated lightweight model GGUF for local inference."""
+    target = model_name.lower().strip()
+    if target not in MODELS_REGISTRY:
+        print(f"[-] Unknown model '{model_name}'. Available options:")
+        for k, v in MODELS_REGISTRY.items():
+            print(f"    - {k} ({v['size_desc']})")
+        return
+
+    info = MODELS_REGISTRY[target]
+    dest_dir = os.path.expanduser("~/models")
+    os.makedirs(dest_dir, exist_ok=True)
+    dest_file = os.path.join(dest_dir, info["filename"])
+
+    if os.path.exists(dest_file):
+        print(f"[*] Model already exists at: {dest_file}")
+        return
+
+    print(f"[*] Downloading {target} ({info['size_desc']}) to {dest_file}...")
+    try:
+        urllib.request.urlretrieve(info["url"], dest_file)
+        print(f"[+] Successfully downloaded: {dest_file}")
+    except Exception as ex:
+        print(f"[-] Download failed: {str(ex)}")
+
+def cmd_serve(port: int, host: str) -> None:
+    """Launches instant 1-line agent server with Live Web Dashboard."""
+    prompt = PromptTemplate.from_template("Edge Task: {input}")
+    chain = prompt | (lambda s: f"termux-aichain processed: {s}")
+    serve(chain, host=host, port=port, block=True)
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="termux-aichain",
+        description="Sovereign Zero-Dependency AI Framework for Termux & Android Edge"
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {__version__}")
+    subparsers = parser.add_subparsers(dest="command", help="Available subcommands")
+
+    # setup
+    subparsers.add_parser("setup", help="Diagnose environment and check native tools")
+
+    # pull
+    pull_parser = subparsers.add_parser("pull", help="Download verified lightweight GGUF model")
+    pull_parser.add_argument("model", choices=list(MODELS_REGISTRY.keys()), help="Target model identifier")
+
+    # serve
+    serve_parser = subparsers.add_parser("serve", help="Launch 1-line REST/SSE/Web Dashboard server")
+    serve_parser.add_argument("--port", type=int, default=8080, help="Port to bind (default: 8080)")
+    serve_parser.add_argument("--host", type=str, default="0.0.0.0", help="Host to bind (default: 0.0.0.0)")
+
+    args = parser.parse_args()
+    if args.command == "setup":
+        cmd_setup()
+    elif args.command == "pull":
+        cmd_pull(args.model)
+    elif args.command == "serve":
+        cmd_serve(args.port, args.host)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

termux_aichain-1.0.0/termux_aichain/core/__init__.py

@@ -0,0 +1,79 @@
+"""
+==============================================================================
+termux-aichain Core Module Exports
+==============================================================================
+"""
+
+from termux_aichain.core.schema import (
+    Message,
+    HumanMessage,
+    AIMessage,
+    SystemMessage,
+    ToolMessage,
+    UsageInfo,
+    GenerationResult,
+    StreamChunk,
+)
+from termux_aichain.core.prompt import (
+    PromptTemplate,
+    ChatPromptTemplate,
+)
+from termux_aichain.core.base import (
+    Runnable,
+    RunnableLambda,
+    RunnableSequence,
+    BaseChatModel,
+)
+from termux_aichain.core.providers.openai_compatible import OpenAICompatibleChat
+from termux_aichain.core.providers.bitnet import BitNetChat
+from termux_aichain.core.providers.local_server import (
+    LocalServerConfig,
+    LocalServerManager,
+    LlamaCppServer,
+    BitNetServer,
+)
+from termux_aichain.core.parsers import (
+    StringOutputParser,
+    JsonOutputParser,
+    RegexOutputParser,
+)
+from termux_aichain.core.splitters import (
+    Document,
+    CharacterTextSplitter,
+    RecursiveCharacterTextSplitter,
+    TextLoader,
+    MarkdownLoader,
+    JSONLoader,
+)
+
+__all__ = [
+    "Message",
+    "HumanMessage",
+    "AIMessage",
+    "SystemMessage",
+    "ToolMessage",
+    "UsageInfo",
+    "GenerationResult",
+    "StreamChunk",
+    "PromptTemplate",
+    "ChatPromptTemplate",
+    "Runnable",
+    "RunnableLambda",
+    "RunnableSequence",
+    "BaseChatModel",
+    "OpenAICompatibleChat",
+    "BitNetChat",
+    "LocalServerConfig",
+    "LocalServerManager",
+    "LlamaCppServer",
+    "BitNetServer",
+    "StringOutputParser",
+    "JsonOutputParser",
+    "RegexOutputParser",
+    "Document",
+    "CharacterTextSplitter",
+    "RecursiveCharacterTextSplitter",
+    "TextLoader",
+    "MarkdownLoader",
+    "JSONLoader",
+]

termux_aichain-1.0.0/termux_aichain/core/base.py

@@ -0,0 +1,144 @@
+"""
+==============================================================================
+termux-aichain Core Engine: Runnable Base & Pipe Composition (|)
+==============================================================================
+Provides standard Runnable, RunnableLambda, RunnableSequence interfaces.
+Zero external heavy dependencies - Pure Python 3.10+ standard library.
+"""
+
+from __future__ import annotations
+import inspect
+import asyncio
+from abc import ABC, abstractmethod
+from typing import Any, AsyncIterator, Callable, Dict, Iterator, List, Optional, Union
+from termux_aichain.core.schema import Message, HumanMessage, AIMessage, GenerationResult, StreamChunk
+
+class Runnable(ABC):
+    """Abstract Base Class for all executable chains, templates, and models."""
+
+    @abstractmethod
+    def invoke(self, input_data: Any, **kwargs: Any) -> Any:
+        pass
+
+    async def ainvoke(self, input_data: Any, **kwargs: Any) -> Any:
+        return await asyncio.to_thread(self.invoke, input_data, **kwargs)
+
+    def stream(self, input_data: Any, **kwargs: Any) -> Iterator[Any]:
+        yield self.invoke(input_data, **kwargs)
+
+    async def astream(self, input_data: Any, **kwargs: Any) -> AsyncIterator[Any]:
+        yield await self.ainvoke(input_data, **kwargs)
+
+    def __or__(self, other: Union[Runnable, Callable[[Any], Any]]) -> RunnableSequence:
+        right = other if isinstance(other, Runnable) else RunnableLambda(other)
+        return RunnableSequence(self, right)
+
+    def __ror__(self, other: Union[Runnable, Callable[[Any], Any]]) -> RunnableSequence:
+        left = other if isinstance(other, Runnable) else RunnableLambda(other)
+        return RunnableSequence(left, self)
+
+class RunnableLambda(Runnable):
+    """Wraps any standard Python callable into a pipe-compatible Runnable."""
+
+    def __init__(self, func: Callable[[Any], Any]):
+        self.func = func
+
+    def invoke(self, input_data: Any, **kwargs: Any) -> Any:
+        if kwargs:
+            return self.func(input_data, **kwargs)
+        return self.func(input_data)
+
+    async def ainvoke(self, input_data: Any, **kwargs: Any) -> Any:
+        if inspect.iscoroutinefunction(self.func):
+            return await self.func(input_data, **kwargs)
+        return await asyncio.to_thread(self.invoke, input_data, **kwargs)
+
+class RunnableSequence(Runnable):
+    """Executes multiple Runnables sequentially in a linear pipe chain."""
+
+    def __init__(self, *steps: Runnable):
+        self.steps: List[Runnable] = []
+        for step in steps:
+            if isinstance(step, RunnableSequence):
+                self.steps.extend(step.steps)
+            elif isinstance(step, Runnable):
+                self.steps.append(step)
+            elif callable(step):
+                self.steps.append(RunnableLambda(step))
+            else:
+                raise TypeError(f"Invalid step in sequence: {type(step)}")
+
+    def invoke(self, input_data: Any, **kwargs: Any) -> Any:
+        current = input_data
+        for step in self.steps:
+            current = step.invoke(current, **kwargs)
+        return current
+
+    async def ainvoke(self, input_data: Any, **kwargs: Any) -> Any:
+        current = input_data
+        for step in self.steps:
+            current = await step.ainvoke(current, **kwargs)
+        return current
+
+    def stream(self, input_data: Any, **kwargs: Any) -> Iterator[Any]:
+        if not self.steps:
+            return
+        if len(self.steps) == 1:
+            yield from self.steps[0].stream(input_data, **kwargs)
+            return
+
+        current = input_data
+        for step in self.steps[:-1]:
+            current = step.invoke(current, **kwargs)
+
+        yield from self.steps[-1].stream(current, **kwargs)
+
+    async def astream(self, input_data: Any, **kwargs: Any) -> AsyncIterator[Any]:
+        if not self.steps:
+            return
+        if len(self.steps) == 1:
+            async for chunk in self.steps[0].astream(input_data, **kwargs):
+                yield chunk
+            return
+
+        current = input_data
+        for step in self.steps[:-1]:
+            current = await step.ainvoke(current, **kwargs)
+
+        async for chunk in self.steps[-1].astream(current, **kwargs):
+            yield chunk
+
+    def __or__(self, other: Union[Runnable, Callable[[Any], Any]]) -> RunnableSequence:
+        right = other if isinstance(other, Runnable) else RunnableLambda(other)
+        return RunnableSequence(*self.steps, right)
+
+class BaseChatModel(Runnable, ABC):
+    """Abstract Base Class for Chat Models."""
+
+    @abstractmethod
+    def generate(self, messages: List[Message]) -> GenerationResult:
+        pass
+
+    async def agenerate(self, messages: List[Message]) -> GenerationResult:
+        return await asyncio.to_thread(self.generate, messages)
+
+    def invoke(self, input_data: Union[str, List[Message], Dict[str, Any]], **kwargs: Any) -> GenerationResult:
+        messages = self._coerce_messages(input_data)
+        return self.generate(messages)
+
+    async def ainvoke(self, input_data: Union[str, List[Message], Dict[str, Any]], **kwargs: Any) -> GenerationResult:
+        messages = self._coerce_messages(input_data)
+        return await self.agenerate(messages)
+
+    def _coerce_messages(self, input_data: Union[str, List[Message], Dict[str, Any]]) -> List[Message]:
+        if isinstance(input_data, str):
+            return [HumanMessage(content=input_data)]
+        elif isinstance(input_data, list):
+            return input_data
+        elif isinstance(input_data, dict):
+            if "messages" in input_data:
+                return input_data["messages"]
+            elif "input" in input_data:
+                return [HumanMessage(content=str(input_data["input"]))]
+            return [HumanMessage(content=str(input_data))]
+        return [HumanMessage(content=str(input_data))]