abstract-toolserver 0.0.1__tar.gz

abstract_toolserver-0.0.1/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: abstract_toolserver
+Version: 0.0.1
+Summary: The abstract_* ecosystem exposed as an API-callable AI toolset: functions become self-describing Flask endpoints with /endpoints discovery and ?help.
+Home-page: https://github.com/AbstractEndeavors/abstract_toolserver
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: abstract_flask
+Requires-Dist: abstract_utilities
+Provides-Extra: files
+Requires-Dist: abstract_search; extra == "files"
+Requires-Dist: abstract_paths; extra == "files"
+Provides-Extra: web
+Requires-Dist: abstract_webtools; extra == "web"
+Provides-Extra: media
+Requires-Dist: abstract_ocr; extra == "media"
+Requires-Dist: abstract_pandas; extra == "media"
+Requires-Dist: media_intelligence; extra == "media"
+Provides-Extra: ai
+Requires-Dist: abstract_ai; extra == "ai"
+Provides-Extra: db
+Requires-Dist: abstract_database; extra == "db"
+Provides-Extra: ui
+Requires-Dist: abstract_clicks; extra == "ui"
+Requires-Dist: abstract_windows; extra == "ui"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# abstract_toolserver
+
+The `abstract_*` ecosystem exposed as an **API-callable AI toolset** — every tool
+is a plain Python function turned into a self-describing HTTP endpoint by
+[`abstract_flask`](https://github.com/AbstractEndeavors/abstract_flask). A portable
+tool layer any model (Claude, hugpy, …) can drive over HTTP instead of being
+bound to one runtime's tool harness.
+
+## Run it
+
+```bash
+pip install abstract_toolserver          # + the extras you want to expose
+python -m abstract_toolserver            # HOST/PORT/DEBUG from TOOLSERVER_* env
+```
+
+```python
+from abstract_toolserver import get_toolserver_app
+app = get_toolserver_app()               # a normal Flask/WSGI app
+```
+
+## Self-describing surface
+
+The app auto-mounts introspection endpoints (from `abstract_flask`):
+
+| Endpoint | What it gives an LLM |
+|---|---|
+| `GET /prefixes` | the tool categories (`/fs`, `/db`, `/ui`, …) |
+| `GET /endpoints` | every tool as `{endpoint, url, methods}` |
+| `GET /<cat>/<tool>?help=true` | that tool's signature/help |
+
+Call a tool with JSON; unknown keys are pruned to the function signature, and the
+reply is `{"result": ...}` (or `{"error": ...}`). Discover-and-dispatch from a
+client is already provided by `abstract_apis.make_endpoint_call`.
+
+```bash
+curl -s localhost:5000/fs/count_tokens -d '{"text":"hello world"}'
+# {"result": 2}
+curl -s localhost:5000/db/schema           # {"result": {table: [cols...]}}
+curl -s 'localhost:5000/db/query?help=true'
+```
+
+## Tool categories
+
+| Prefix | Tools | Backend |
+|---|---|---|
+| `/fs` | search, read_span, extract, read_file, write_file, read_json, find_keys, find_paths, glob, imports, find_content | abstract_search, abstract_utilities, abstract_paths |
+| `/text` | count_tokens, chunk, detect_language | abstract_utilities |
+| `/web` | text, links, attributes | abstract_webtools |
+| `/media` | ocr_image, pdf_text, summarize, keywords, transcribe | abstract_ocr, abstract_pandas, media_intelligence |
+| `/ai` | query | abstract_ai |
+| `/db` | tables, schema, columns, fetch, **query** | abstract_database |
+| `/sys` | run_cmd | stdlib (gated) |
+| `/ui` | capture, monitors, ocr, windows, **click_verify** | abstract_clicks, abstract_windows |
+
+## Safety gates
+
+Backends load lazily, so the server boots on a headless box and a missing backend
+errors only when its tool is called. Beyond that:
+
+- **`/db/query`** — read-only gate: rejects anything that isn't a single
+  `SELECT`/`WITH`, blocks stacked statements and data-modifying keywords. Use
+  `/db/fetch` (identifier-composed, params-not-SQL) as the default read path.
+- **`/sys/run_cmd`** — disabled unless `TOOLSERVER_CMD_ALLOWLIST=ls,grep,…` is set;
+  only allowlisted binaries run.
+- **`/fs/read_file` · `/fs/write_file`** — local-only; the underlying SSH/remote
+  kwargs are never exposed at the boundary.
+- **`/ui/click_verify`** — the click→observe→**verify** loop: locate (text or image
+  template) → click → re-capture → report whether the screen (or a `region`)
+  changed. The half most tool APIs lack.
+
+## Configuration
+
+| Env var | Purpose |
+|---|---|
+| `TOOLSERVER_HOST` / `TOOLSERVER_PORT` / `TOOLSERVER_DEBUG` | bind + debug |
+| `TOOLSERVER_CMD_ALLOWLIST` | comma-separated binaries `/sys/run_cmd` may run |
+| `SOLCATCHER_POSTGRESQL_*` | DB connection (via abstract_database) |

abstract_toolserver-0.0.1/README.md

@@ -0,0 +1,77 @@
+# abstract_toolserver
+
+The `abstract_*` ecosystem exposed as an **API-callable AI toolset** — every tool
+is a plain Python function turned into a self-describing HTTP endpoint by
+[`abstract_flask`](https://github.com/AbstractEndeavors/abstract_flask). A portable
+tool layer any model (Claude, hugpy, …) can drive over HTTP instead of being
+bound to one runtime's tool harness.
+
+## Run it
+
+```bash
+pip install abstract_toolserver          # + the extras you want to expose
+python -m abstract_toolserver            # HOST/PORT/DEBUG from TOOLSERVER_* env
+```
+
+```python
+from abstract_toolserver import get_toolserver_app
+app = get_toolserver_app()               # a normal Flask/WSGI app
+```
+
+## Self-describing surface
+
+The app auto-mounts introspection endpoints (from `abstract_flask`):
+
+| Endpoint | What it gives an LLM |
+|---|---|
+| `GET /prefixes` | the tool categories (`/fs`, `/db`, `/ui`, …) |
+| `GET /endpoints` | every tool as `{endpoint, url, methods}` |
+| `GET /<cat>/<tool>?help=true` | that tool's signature/help |
+
+Call a tool with JSON; unknown keys are pruned to the function signature, and the
+reply is `{"result": ...}` (or `{"error": ...}`). Discover-and-dispatch from a
+client is already provided by `abstract_apis.make_endpoint_call`.
+
+```bash
+curl -s localhost:5000/fs/count_tokens -d '{"text":"hello world"}'
+# {"result": 2}
+curl -s localhost:5000/db/schema           # {"result": {table: [cols...]}}
+curl -s 'localhost:5000/db/query?help=true'
+```
+
+## Tool categories
+
+| Prefix | Tools | Backend |
+|---|---|---|
+| `/fs` | search, read_span, extract, read_file, write_file, read_json, find_keys, find_paths, glob, imports, find_content | abstract_search, abstract_utilities, abstract_paths |
+| `/text` | count_tokens, chunk, detect_language | abstract_utilities |
+| `/web` | text, links, attributes | abstract_webtools |
+| `/media` | ocr_image, pdf_text, summarize, keywords, transcribe | abstract_ocr, abstract_pandas, media_intelligence |
+| `/ai` | query | abstract_ai |
+| `/db` | tables, schema, columns, fetch, **query** | abstract_database |
+| `/sys` | run_cmd | stdlib (gated) |
+| `/ui` | capture, monitors, ocr, windows, **click_verify** | abstract_clicks, abstract_windows |
+
+## Safety gates
+
+Backends load lazily, so the server boots on a headless box and a missing backend
+errors only when its tool is called. Beyond that:
+
+- **`/db/query`** — read-only gate: rejects anything that isn't a single
+  `SELECT`/`WITH`, blocks stacked statements and data-modifying keywords. Use
+  `/db/fetch` (identifier-composed, params-not-SQL) as the default read path.
+- **`/sys/run_cmd`** — disabled unless `TOOLSERVER_CMD_ALLOWLIST=ls,grep,…` is set;
+  only allowlisted binaries run.
+- **`/fs/read_file` · `/fs/write_file`** — local-only; the underlying SSH/remote
+  kwargs are never exposed at the boundary.
+- **`/ui/click_verify`** — the click→observe→**verify** loop: locate (text or image
+  template) → click → re-capture → report whether the screen (or a `region`)
+  changed. The half most tool APIs lack.
+
+## Configuration
+
+| Env var | Purpose |
+|---|---|
+| `TOOLSERVER_HOST` / `TOOLSERVER_PORT` / `TOOLSERVER_DEBUG` | bind + debug |
+| `TOOLSERVER_CMD_ALLOWLIST` | comma-separated binaries `/sys/run_cmd` may run |
+| `SOLCATCHER_POSTGRESQL_*` | DB connection (via abstract_database) |

abstract_toolserver-0.0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

abstract_toolserver-0.0.1/setup.cfg

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

abstract_toolserver-0.0.1/setup.py

@@ -0,0 +1,44 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name='abstract_toolserver',
+    version='0.0.1',
+    author='putkoff',
+    author_email='partners@abstractendeavors.com',
+    description="The abstract_* ecosystem exposed as an API-callable AI toolset: functions become self-describing Flask endpoints with /endpoints discovery and ?help.",
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url="https://github.com/AbstractEndeavors/abstract_toolserver",
+    classifiers=[
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.11',
+    ],
+    install_requires=[
+        'abstract_flask',
+        'abstract_utilities',
+    ],
+    extras_require={
+        # Tool backends are imported lazily; install only what you expose.
+        'files': ['abstract_search', 'abstract_paths'],
+        'web': ['abstract_webtools'],
+        'media': ['abstract_ocr', 'abstract_pandas', 'media_intelligence'],
+        'ai': ['abstract_ai'],
+        'db': ['abstract_database'],
+        'ui': ['abstract_clicks', 'abstract_windows'],
+    },
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+    python_requires=">=3.8",
+    entry_points={
+        "console_scripts": [
+            "abstract-toolserver = abstract_toolserver.app:main",
+        ],
+    },
+    setup_requires=['wheel'],
+)

abstract_toolserver-0.0.1/src/abstract_toolserver/__init__.py

@@ -0,0 +1,5 @@
+"""abstract_toolserver — the abstract_* ecosystem exposed as an API-callable AI toolset."""
+from .app import get_toolserver_app, main
+from .tools import TOOLSETS
+
+__all__ = ["get_toolserver_app", "main", "TOOLSETS"]

abstract_toolserver-0.0.1/src/abstract_toolserver/__main__.py

@@ -0,0 +1,5 @@
+"""python -m abstract_toolserver → run the server."""
+from .app import main
+
+if __name__ == "__main__":
+    main()

abstract_toolserver-0.0.1/src/abstract_toolserver/app.py

@@ -0,0 +1,33 @@
+"""
+App factory + runner for the AI toolserver.
+
+    from abstract_toolserver.app import get_toolserver_app
+    app = get_toolserver_app()          # WSGI app, /endpoints + /prefixes + ?help
+    app.run()
+
+or just:  python -m abstract_toolserver
+"""
+from abstract_flask import get_Flask_app, main_flask_start
+
+from . import routes
+
+
+def get_toolserver_app(allowed_origins=None, debug=None, **flask_kwargs):
+    """Return the fully-wired Flask app (all tool blueprints + introspection)."""
+    return get_Flask_app(
+        name="abstract_toolserver",
+        routes=routes,
+        allowed_origins=allowed_origins,
+        debug=debug,
+        **flask_kwargs,
+    )
+
+
+def main():
+    """Run the server; HOST/PORT/DEBUG come from TOOLSERVER_* env vars."""
+    app = get_toolserver_app()
+    main_flask_start(app, key_head="TOOLSERVER")
+
+
+if __name__ == "__main__":
+    main()

abstract_toolserver-0.0.1/src/abstract_toolserver/gates.py

@@ -0,0 +1,109 @@
+"""
+Safety gates and lazy-import plumbing for the AI toolserver.
+
+Everything a tool needs to be *safe to expose over HTTP* lives here:
+  * lazy import so the Flask app boots even when a heavy backend is absent,
+  * a read-only SQL guard for the raw-query tool,
+  * a command allowlist for shell exec (off by default),
+  * a scrubber that strips the SSH/remote-exec kwargs off the file tools.
+"""
+import importlib
+import os
+import re
+import shlex
+
+
+class ToolError(Exception):
+    """Raised by a tool wrapper; the Flask layer turns it into {"error": ...}."""
+
+
+# ──────────────────────────────────────────────────────────
+# Lazy import  ("pkg.module:attr"  or  "pkg.module")
+# ──────────────────────────────────────────────────────────
+def lazy(path):
+    """Import on first call so a missing backend can't stop the server booting."""
+    module, _, attr = path.partition(":")
+    try:
+        mod = importlib.import_module(module)
+    except Exception as e:  # ImportError, or a backend that explodes at import
+        raise ToolError(f"backend '{module}' unavailable: {e}")
+    if not attr:
+        return mod
+    try:
+        return getattr(mod, attr)
+    except AttributeError:
+        raise ToolError(f"'{module}' has no attribute '{attr}'")
+
+
+def first_lazy(*paths):
+    """Return the first import path that resolves; used when a symbol moved."""
+    last = None
+    for p in paths:
+        try:
+            return lazy(p)
+        except ToolError as e:
+            last = e
+    raise last or ToolError("no import path resolved")
+
+
+# ──────────────────────────────────────────────────────────
+# SQL read-only guard
+# ──────────────────────────────────────────────────────────
+_WRITE_TOKENS = re.compile(
+    r"\b(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|TRUNCATE|GRANT|REVOKE|"
+    r"COPY|MERGE|CALL|DO|VACUUM|REINDEX|COMMENT|SET)\b",
+    re.IGNORECASE,
+)
+
+
+def assert_readonly_sql(query):
+    """Reject anything that isn't a single SELECT/WITH read. Raises ToolError."""
+    if not isinstance(query, str) or not query.strip():
+        raise ToolError("query must be a non-empty string")
+    stripped = query.strip().rstrip(";").strip()
+    # block stacked statements (a trailing ';' was already removed above)
+    if ";" in stripped:
+        raise ToolError("multiple statements are not allowed")
+    if not re.match(r"^(SELECT|WITH)\b", stripped, re.IGNORECASE):
+        raise ToolError("only SELECT / WITH queries are allowed")
+    if _WRITE_TOKENS.search(stripped):
+        raise ToolError("query contains a data-modifying keyword")
+    return stripped
+
+
+# ──────────────────────────────────────────────────────────
+# Shell command allowlist  (run_cmd is OFF unless explicitly enabled)
+# ──────────────────────────────────────────────────────────
+def _allowlist():
+    raw = os.environ.get("TOOLSERVER_CMD_ALLOWLIST", "")
+    return {c.strip() for c in raw.split(",") if c.strip()}
+
+
+def assert_cmd_allowed(cmd):
+    """Only permit a binary named in TOOLSERVER_CMD_ALLOWLIST. Raises ToolError."""
+    allow = _allowlist()
+    if not allow:
+        raise ToolError(
+            "run_cmd disabled — set TOOLSERVER_CMD_ALLOWLIST=ls,grep,... to enable"
+        )
+    try:
+        parts = shlex.split(cmd)
+    except ValueError as e:
+        raise ToolError(f"unparseable command: {e}")
+    if not parts:
+        raise ToolError("empty command")
+    binary = os.path.basename(parts[0])
+    if binary not in allow:
+        raise ToolError(f"'{binary}' not in allowlist {sorted(allow)}")
+    return parts
+
+
+# ──────────────────────────────────────────────────────────
+# File-tool kwarg scrubber
+# ──────────────────────────────────────────────────────────
+_SSH_KEYS = {"user_at_host", "password", "key", "host", "ssh", "remote"}
+
+
+def strip_remote_kwargs(kwargs):
+    """Drop the SSH/remote-exec kwargs so file tools stay local-only."""
+    return {k: v for k, v in kwargs.items() if k not in _SSH_KEYS}

abstract_toolserver-0.0.1/src/abstract_toolserver/routes/__init__.py

@@ -0,0 +1,16 @@
+"""
+Routes module consumed by abstract_flask.get_Flask_app(routes=...).
+
+get_Flask_app scans this module for any top-level object named ``*_bp`` that is
+a Blueprint and registers it, so all we do here is build one blueprint and hang
+every tool category off it via register_categories.
+"""
+from abstract_flask import get_bp, register_categories
+
+from ..tools import TOOLSETS
+
+# name → "tools_bp" so the factory's *_bp auto-discovery finds it
+tools_bp, logger = get_bp("tools", __name__)
+
+# {category: {route: func}} → /category/route  (+ /category/route/ , GET+POST)
+register_categories(tools_bp, TOOLSETS)

abstract_toolserver-0.0.1/src/abstract_toolserver/tools.py

@@ -0,0 +1,367 @@
+"""
+The compiled AI toolset.
+
+Each function here is a thin, JSON-in / JSON-out wrapper over a symbol that
+already exists in the abstract_* ecosystem. Backends are imported lazily (via
+gates.lazy) so this module imports cleanly on a headless box; a tool whose
+backend is missing raises ToolError only when actually called.
+
+The TOOLSETS dict at the bottom is the whole API surface — it maps
+{category: {route_name: callable}} and is fed straight to
+abstract_flask.register_categories.
+"""
+import hashlib
+import os
+import time
+
+from .gates import (
+    ToolError,
+    assert_cmd_allowed,
+    assert_readonly_sql,
+    first_lazy,
+    lazy,
+    strip_remote_kwargs,
+)
+
+
+# ══════════════════════════════════════════════════════════
+# FILES / CODE  (abstract_search, abstract_utilities, abstract_paths)
+# ══════════════════════════════════════════════════════════
+def search_files(needle, paths, case_sensitive=False, regex=False):
+    """Grep a string/regex across files or dirs (code, office, pdf)."""
+    fn = lazy("abstract_search:search_files")
+    return fn(needle, paths, case_sensitive=case_sensitive, regex=regex)
+
+
+def read_span(path, ranges=None):
+    """Read 1-based inclusive line ranges from one file (whole file if omitted)."""
+    return lazy("abstract_search:read_span")(path, ranges=ranges)
+
+
+def extract_text(path):
+    """Any single file → plain text (pdf/docx/xlsx/pptx/code); errors-as-data."""
+    return lazy("abstract_search:extract_text")(path)
+
+
+def read_file(file_path):
+    """Read a local text file (SSH/remote kwargs are intentionally not exposed)."""
+    return lazy("abstract_utilities:read_from_file")(file_path=file_path)
+
+
+def write_file(file_path, contents):
+    """Write text to a local file (local-only; remote-exec kwargs stripped)."""
+    fn = lazy("abstract_utilities:write_to_file")
+    return fn(contents=contents, file_path=file_path, **strip_remote_kwargs({}))
+
+
+def read_json(file_path):
+    """Robustly load a JSON file."""
+    return lazy("abstract_utilities:safe_read_from_json")(file_path)
+
+
+def find_keys(data, target_keys):
+    """Recursively collect all values for the given keys in nested JSON."""
+    return lazy("abstract_utilities:find_keys")(data, target_keys)
+
+
+def find_paths_to_key(data, key):
+    """Return the paths where a key occurs in nested JSON."""
+    return lazy("abstract_utilities:find_paths_to_key")(data, key)
+
+
+def count_tokens(text, model_name="gpt-4"):
+    """Count LLM tokens in a string."""
+    return lazy("abstract_utilities:num_tokens_from_string")(text, model_name=model_name)
+
+
+def chunk_text(data, max_tokens, model_name="gpt-4"):
+    """Split text/code into token-bounded chunks."""
+    return lazy("abstract_utilities:chunk_any_to_tokens")(data, max_tokens, model_name=model_name)
+
+
+def detect_language(text):
+    """Heuristically identify the programming language of a snippet."""
+    return lazy("abstract_utilities:detect_language_from_text")(text)
+
+
+def glob_files(path, pattern, ext=None):
+    """Glob files under a path by pattern."""
+    return lazy("abstract_paths:glob_search")(path, pattern, ext=ext)
+
+
+def python_imports(file_path):
+    """List the imports of a Python file."""
+    return lazy("abstract_paths:extract_python_imports")(file_path)
+
+
+def find_content(dirs, strings, get_lines=True):
+    """grep-like recursive search: files containing the given strings (+line nums)."""
+    fn = first_lazy(
+        "abstract_paths.content_utils.backs:findContent",
+        "abstract_paths:findContent",
+    )
+    dirs = dirs if isinstance(dirs, (list, tuple)) else [dirs]
+    return fn(*dirs, strings=strings, get_lines=get_lines)
+
+
+# ══════════════════════════════════════════════════════════
+# WEB  (abstract_webtools)
+# ══════════════════════════════════════════════════════════
+def web_text(url):
+    """Fetch a URL and return its visible page text."""
+    return lazy("abstract_webtools:get_soup_text")(url)
+
+
+def web_links(url):
+    """Crawl a page and return every link on it."""
+    return lazy("abstract_webtools:get_all_crawl_links")(url)
+
+
+def web_attributes(url, tags_list=None):
+    """Extract attribute values for given tags on a page."""
+    return lazy("abstract_webtools:get_all_attribute_values")(url=url, tags_list=tags_list)
+
+
+# ══════════════════════════════════════════════════════════
+# MEDIA → TEXT  (abstract_ocr, abstract_pandas, media_intelligence)
+# ══════════════════════════════════════════════════════════
+def ocr_image(image_path):
+    """OCR a single image to text."""
+    return first_lazy(
+        "abstract_ocr:extract_text_from_image",
+        "media_intelligence.ocr:image_to_text",
+    )(image_path)
+
+
+def pdf_text(path, ocr_if_empty=True):
+    """Full text of a PDF (pdfplumber + OCR fallback)."""
+    return lazy("abstract_pandas:pdf_to_text")(path, ocr_if_empty=ocr_if_empty)
+
+
+def summarize(text, max_output_words=None):
+    """Abstractive summary of text (delegates to the media_intelligence facade)."""
+    fn = first_lazy("media_intelligence.enrich:summarize", "abstract_hugpy:summarize")
+    return fn(text=text, max_output_words=max_output_words) if max_output_words else fn(text=text)
+
+
+def keywords(text, top_n=None):
+    """Keyword/keyphrase extraction from text."""
+    fn = first_lazy("media_intelligence.enrich:keywords", "abstract_hugpy:extract_keywords")
+    return fn(text, top_n=top_n) if top_n else fn(text)
+
+
+def transcribe(path):
+    """Transcribe a local audio/video file to text."""
+    return first_lazy(
+        "media_intelligence.transcribe:transcribe",
+        "abstract_hugpy:whisper_transcribe",
+    )(path)
+
+
+# ══════════════════════════════════════════════════════════
+# AI / LLM  (abstract_ai)
+# ══════════════════════════════════════════════════════════
+def ai_query(prompt, model=None, completion_percentage=50):
+    """Run one prompt through the abstract_ai model pipeline."""
+    fn = lazy("abstract_ai:make_general_query")
+    return fn(prompt=prompt, model=model, completion_percentage=completion_percentage)
+
+
+# ══════════════════════════════════════════════════════════
+# DATABASE  (abstract_database) — server-side, co-located
+# ══════════════════════════════════════════════════════════
+def db_tables(schema="public"):
+    """List table names in a schema."""
+    return lazy("abstract_database:get_all_table_names")(schema=schema)
+
+
+def db_schema(schema="public"):
+    """Map every table to its columns — let the model discover the DB."""
+    return lazy("abstract_database:get_all_table_info")(schema=schema)
+
+
+def db_columns(table_name, schema="public"):
+    """List the columns of one table."""
+    return lazy("abstract_database:get_column_names")(table_name, schema=schema)
+
+
+def db_fetch(table_name, column_names="*", search_map=None, any_value=False, schema="public"):
+    """Safe, identifier-composed SELECT (the model supplies params, not SQL)."""
+    fn = lazy("abstract_database:fetch_any_combo_")
+    return fn(
+        table_name=table_name,
+        column_names=column_names,
+        search_map=search_map,
+        any_value=any_value,
+        schema=schema,
+    )
+
+
+def db_query(query, values=None):
+    """Run a raw SELECT/WITH query (read-only gate: writes are rejected)."""
+    safe = assert_readonly_sql(query)
+    return lazy("abstract_database:execute_query")(safe, values=values, fetch=True)
+
+
+# ══════════════════════════════════════════════════════════
+# SYSTEM  (gated)
+# ══════════════════════════════════════════════════════════
+def run_cmd(cmd):
+    """Run a shell command — only binaries in TOOLSERVER_CMD_ALLOWLIST (off by default)."""
+    import subprocess
+
+    parts = assert_cmd_allowed(cmd)
+    proc = subprocess.run(parts, capture_output=True, text=True, timeout=60)
+    return {"returncode": proc.returncode, "stdout": proc.stdout, "stderr": proc.stderr}
+
+
+# ══════════════════════════════════════════════════════════
+# COMPUTER-USE  (abstract_clicks / abstract_windows)  + the verify glue
+# ══════════════════════════════════════════════════════════
+def screen_capture(monitor_index=1, output_path=None):
+    """Screenshot one monitor to a PNG; returns the file path."""
+    return lazy("abstract_clicks.utils.monitor_utils:capture_monitor")(monitor_index, output_path=output_path)
+
+
+def screen_monitors():
+    """Enumerate monitors with geometry."""
+    return lazy("abstract_clicks.utils.monitor_utils:get_monitors")()
+
+
+def screen_ocr(screenshot_file="new_screen.png", confidence_threshold=60):
+    """OCR the screen → list of {text,x,y,width,height,confidence}."""
+    return first_lazy(
+        "abstract_clicks:perform_ocr",
+        "abstract_clicks.managers.clipboardManager.utils:perform_ocr",
+    )(screenshot_file, confidence_threshold=confidence_threshold)
+
+
+def list_windows(with_geometry=True):
+    """Enumerate all open windows with geometry + process info (X11)."""
+    fn = lazy("abstract_windows.window_utils.window_utils:get_all_parsed_windows")
+    return fn(with_signature=True, with_geometry=with_geometry)
+
+
+def _locate(target=None, template_path=None, monitor_index=1):
+    """Return (x, y) screen coords for a text target or an image template, or None."""
+    shot = screen_capture(monitor_index=monitor_index)
+    if template_path:
+        matches = first_lazy(
+            "abstract_clicks:get_ocr_locate_image",
+            "abstract_clicks.managers.clipboardManager.clipboardManager:ocr_locate_image",
+        )(shot, template_path)
+        if matches:
+            m = matches[0]
+            c = m.get("center") or (m.get("x"), m.get("y"))
+            return (int(c[0]), int(c[1]))
+        return None
+    # text target via OCR box centres
+    boxes = screen_ocr(shot)
+    tl = (target or "").strip().lower()
+    for b in boxes or []:
+        if tl and tl in str(b.get("text", "")).strip().lower():
+            return (int(b["x"] + b.get("width", 0) / 2), int(b["y"] + b.get("height", 0) / 2))
+    return None
+
+
+def _region_hash(png_path, region=None):
+    if region:
+        try:
+            Image = lazy("PIL.Image:")  # module
+            img = Image.open(png_path)
+            x, y, w, h = region
+            img = img.crop((x, y, x + w, y + h))
+            return hashlib.sha256(img.tobytes()).hexdigest()
+        except ToolError:
+            pass  # PIL missing → fall through to full-file hash
+    with open(png_path, "rb") as fh:
+        return hashlib.sha256(fh.read()).hexdigest()
+
+
+def click_and_verify(target=None, template_path=None, x=None, y=None,
+                     monitor_index=1, region=None, settle=0.6):
+    """
+    The missing computer-use loop: locate → click → re-capture → report whether
+    the screen changed. Supply either explicit (x,y), a text `target`, or an
+    image `template_path`. `region`=[x,y,w,h] narrows the change check.
+    """
+    try:
+        gui = lazy("abstract_clicks.managers.importClasses.importClasses:get_auto_gui")()
+    except ToolError:
+        gui = lazy("pyautogui:")  # empty attr → the module itself
+
+    if x is None or y is None:
+        coords = _locate(target=target, template_path=template_path, monitor_index=monitor_index)
+        if not coords:
+            return {"clicked": None, "changed": False,
+                    "error": "target not found on screen"}
+        x, y = coords
+
+    before = screen_capture(monitor_index=monitor_index)
+    b_hash = _region_hash(before, region)
+
+    gui.click(x, y)
+    time.sleep(settle)
+
+    after = screen_capture(monitor_index=monitor_index)
+    a_hash = _region_hash(after, region)
+
+    return {"clicked": [int(x), int(y)], "changed": b_hash != a_hash,
+            "before": before, "after": after}
+
+
+# ══════════════════════════════════════════════════════════
+# THE API SURFACE  →  {category: {route: func}}
+# ══════════════════════════════════════════════════════════
+TOOLSETS = {
+    "fs": {
+        "search": search_files,
+        "read_span": read_span,
+        "extract": extract_text,
+        "read_file": read_file,
+        "write_file": write_file,
+        "read_json": read_json,
+        "find_keys": find_keys,
+        "find_paths": find_paths_to_key,
+        "glob": glob_files,
+        "imports": python_imports,
+        "find_content": find_content,
+    },
+    "text": {
+        "count_tokens": count_tokens,
+        "chunk": chunk_text,
+        "detect_language": detect_language,
+    },
+    "web": {
+        "text": web_text,
+        "links": web_links,
+        "attributes": web_attributes,
+    },
+    "media": {
+        "ocr_image": ocr_image,
+        "pdf_text": pdf_text,
+        "summarize": summarize,
+        "keywords": keywords,
+        "transcribe": transcribe,
+    },
+    "ai": {
+        "query": ai_query,
+    },
+    "db": {
+        "tables": db_tables,
+        "schema": db_schema,
+        "columns": db_columns,
+        "fetch": db_fetch,
+        "query": db_query,           # SELECT-only gated
+    },
+    "sys": {
+        "run_cmd": run_cmd,          # allowlist gated, off by default
+    },
+    "ui": {
+        "capture": screen_capture,
+        "monitors": screen_monitors,
+        "ocr": screen_ocr,
+        "windows": list_windows,
+        "click_verify": click_and_verify,
+    },
+}

abstract_toolserver-0.0.1/src/abstract_toolserver.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: abstract_toolserver
+Version: 0.0.1
+Summary: The abstract_* ecosystem exposed as an API-callable AI toolset: functions become self-describing Flask endpoints with /endpoints discovery and ?help.
+Home-page: https://github.com/AbstractEndeavors/abstract_toolserver
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: abstract_flask
+Requires-Dist: abstract_utilities
+Provides-Extra: files
+Requires-Dist: abstract_search; extra == "files"
+Requires-Dist: abstract_paths; extra == "files"
+Provides-Extra: web
+Requires-Dist: abstract_webtools; extra == "web"
+Provides-Extra: media
+Requires-Dist: abstract_ocr; extra == "media"
+Requires-Dist: abstract_pandas; extra == "media"
+Requires-Dist: media_intelligence; extra == "media"
+Provides-Extra: ai
+Requires-Dist: abstract_ai; extra == "ai"
+Provides-Extra: db
+Requires-Dist: abstract_database; extra == "db"
+Provides-Extra: ui
+Requires-Dist: abstract_clicks; extra == "ui"
+Requires-Dist: abstract_windows; extra == "ui"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# abstract_toolserver
+
+The `abstract_*` ecosystem exposed as an **API-callable AI toolset** — every tool
+is a plain Python function turned into a self-describing HTTP endpoint by
+[`abstract_flask`](https://github.com/AbstractEndeavors/abstract_flask). A portable
+tool layer any model (Claude, hugpy, …) can drive over HTTP instead of being
+bound to one runtime's tool harness.
+
+## Run it
+
+```bash
+pip install abstract_toolserver          # + the extras you want to expose
+python -m abstract_toolserver            # HOST/PORT/DEBUG from TOOLSERVER_* env
+```
+
+```python
+from abstract_toolserver import get_toolserver_app
+app = get_toolserver_app()               # a normal Flask/WSGI app
+```
+
+## Self-describing surface
+
+The app auto-mounts introspection endpoints (from `abstract_flask`):
+
+| Endpoint | What it gives an LLM |
+|---|---|
+| `GET /prefixes` | the tool categories (`/fs`, `/db`, `/ui`, …) |
+| `GET /endpoints` | every tool as `{endpoint, url, methods}` |
+| `GET /<cat>/<tool>?help=true` | that tool's signature/help |
+
+Call a tool with JSON; unknown keys are pruned to the function signature, and the
+reply is `{"result": ...}` (or `{"error": ...}`). Discover-and-dispatch from a
+client is already provided by `abstract_apis.make_endpoint_call`.
+
+```bash
+curl -s localhost:5000/fs/count_tokens -d '{"text":"hello world"}'
+# {"result": 2}
+curl -s localhost:5000/db/schema           # {"result": {table: [cols...]}}
+curl -s 'localhost:5000/db/query?help=true'
+```
+
+## Tool categories
+
+| Prefix | Tools | Backend |
+|---|---|---|
+| `/fs` | search, read_span, extract, read_file, write_file, read_json, find_keys, find_paths, glob, imports, find_content | abstract_search, abstract_utilities, abstract_paths |
+| `/text` | count_tokens, chunk, detect_language | abstract_utilities |
+| `/web` | text, links, attributes | abstract_webtools |
+| `/media` | ocr_image, pdf_text, summarize, keywords, transcribe | abstract_ocr, abstract_pandas, media_intelligence |
+| `/ai` | query | abstract_ai |
+| `/db` | tables, schema, columns, fetch, **query** | abstract_database |
+| `/sys` | run_cmd | stdlib (gated) |
+| `/ui` | capture, monitors, ocr, windows, **click_verify** | abstract_clicks, abstract_windows |
+
+## Safety gates
+
+Backends load lazily, so the server boots on a headless box and a missing backend
+errors only when its tool is called. Beyond that:
+
+- **`/db/query`** — read-only gate: rejects anything that isn't a single
+  `SELECT`/`WITH`, blocks stacked statements and data-modifying keywords. Use
+  `/db/fetch` (identifier-composed, params-not-SQL) as the default read path.
+- **`/sys/run_cmd`** — disabled unless `TOOLSERVER_CMD_ALLOWLIST=ls,grep,…` is set;
+  only allowlisted binaries run.
+- **`/fs/read_file` · `/fs/write_file`** — local-only; the underlying SSH/remote
+  kwargs are never exposed at the boundary.
+- **`/ui/click_verify`** — the click→observe→**verify** loop: locate (text or image
+  template) → click → re-capture → report whether the screen (or a `region`)
+  changed. The half most tool APIs lack.
+
+## Configuration
+
+| Env var | Purpose |
+|---|---|
+| `TOOLSERVER_HOST` / `TOOLSERVER_PORT` / `TOOLSERVER_DEBUG` | bind + debug |
+| `TOOLSERVER_CMD_ALLOWLIST` | comma-separated binaries `/sys/run_cmd` may run |
+| `SOLCATCHER_POSTGRESQL_*` | DB connection (via abstract_database) |

abstract_toolserver-0.0.1/src/abstract_toolserver.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+setup.py
+src/abstract_toolserver/__init__.py
+src/abstract_toolserver/__main__.py
+src/abstract_toolserver/app.py
+src/abstract_toolserver/gates.py
+src/abstract_toolserver/tools.py
+src/abstract_toolserver.egg-info/PKG-INFO
+src/abstract_toolserver.egg-info/SOURCES.txt
+src/abstract_toolserver.egg-info/dependency_links.txt
+src/abstract_toolserver.egg-info/entry_points.txt
+src/abstract_toolserver.egg-info/requires.txt
+src/abstract_toolserver.egg-info/top_level.txt
+src/abstract_toolserver/routes/__init__.py

abstract_toolserver-0.0.1/src/abstract_toolserver.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

abstract_toolserver-0.0.1/src/abstract_toolserver.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+abstract-toolserver = abstract_toolserver.app:main

abstract_toolserver-0.0.1/src/abstract_toolserver.egg-info/requires.txt

@@ -0,0 +1,24 @@
+abstract_flask
+abstract_utilities
+
+[ai]
+abstract_ai
+
+[db]
+abstract_database
+
+[files]
+abstract_search
+abstract_paths
+
+[media]
+abstract_ocr
+abstract_pandas
+media_intelligence
+
+[ui]
+abstract_clicks
+abstract_windows
+
+[web]
+abstract_webtools

abstract_toolserver-0.0.1/src/abstract_toolserver.egg-info/top_level.txt

@@ -0,0 +1 @@
+abstract_toolserver