agent-code 1.0.0__py3-none-any.whl

agent_code/cli.py

@@ -0,0 +1,69 @@
+"""CLI entry point. Subcommands: run, manage, serve, skills."""
+import sys, argparse
+from . import __version__
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        prog="agent-code",
+        description="Local AI agent with headless browser and skills.")
+    ap.add_argument("--version", action="version",
+                    version=f"agent-code {__version__}")
+    sub = ap.add_subparsers(dest="cmd")
+
+    sub.add_parser("run", help="run the agent (default)").set_defaults(func=_run)
+    sub.add_parser("manage", help="skill manager GUI").set_defaults(func=_manage)
+
+    p = sub.add_parser("serve", help="serve the landing page")
+    p.add_argument("--host", default=None)
+    p.add_argument("--port", type=int, default=None)
+    p.set_defaults(func=_serve)
+
+    p = sub.add_parser("skills", help="list or install bundled skills")
+    p.add_argument("action", nargs="?", default="list",
+                   choices=["list", "install"])
+    p.set_defaults(func=_skills)
+
+    args = ap.parse_args(argv)
+    if args.cmd is None:
+        return _run(args)
+    return args.func(args)
+
+def _run(args):
+    from .agent import main as m
+    m(); return 0
+
+def _manage(args):
+    from .skill_manager import main as m
+    m(); return 0
+
+def _serve(args):
+    try:
+        from .landing import main as m
+    except ImportError:
+        print("Landing page not bundled in this install.")
+        return 1
+    argv = []
+    if args.host: argv += ["--host", args.host]
+    if args.port: argv += ["--port", str(args.port)]
+    return m(argv) or 0
+
+def _skills(args):
+    from .paths import (install_bundled_skills, list_bundled_skills,
+                        project_skills_dir)
+    if args.action == "list":
+        print("Bundled skills:")
+        for n in list_bundled_skills():
+            print(f"  - {n}")
+        print()
+        print(f"Install location: {project_skills_dir()}")
+        return 0
+    copied = install_bundled_skills(overwrite=False)
+    if not copied:
+        print("All bundled skills are already installed.")
+    else:
+        for name in copied:
+            print(f"  installed: {name}")
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

agent_code/data/skills/filesystem/skill.py

@@ -0,0 +1,133 @@
+"""filesystem skill — read/write files, confined to the workspace sandbox."""
+
+import os
+from pathlib import Path
+
+SKILL = {
+    "name": "filesystem",
+    "description": (
+        "Create, read, and list files INSIDE the sandbox workspace. "
+        "write_file creates a file, append_file adds chunks, read_file "
+        "inspects, list_dir explores. Paths are relative to the workspace."
+    ),
+}
+
+WORKSPACE = Path(os.environ.get("AGENT_WORKSPACE", "workspace")).resolve()
+WORKSPACE.mkdir(parents=True, exist_ok=True)
+
+MAX_READ = 20_000
+MAX_WRITE_CHUNK = 200_000   # ~200 KB per call
+
+
+def _safe(path: str) -> Path:
+    """Resolve `path` under WORKSPACE; reject anything that escapes."""
+    if not isinstance(path, str):
+        raise ValueError("path must be a string")
+    if os.path.isabs(path):
+        p = Path(path).resolve()
+        if not str(p).startswith(str(WORKSPACE)):
+            raise ValueError(f"absolute path outside workspace: {path}")
+        return p
+    p = (WORKSPACE / path).resolve()
+    if not str(p).startswith(str(WORKSPACE)):
+        raise ValueError(f"path escapes workspace: {path}")
+    return p
+
+
+def write_file(path: str, content: str) -> str:
+    """Create or overwrite a file. Content capped at MAX_WRITE_CHUNK."""
+    try:
+        if not isinstance(content, str):
+            return "ERROR: content must be a string"
+        if len(content) > MAX_WRITE_CHUNK:
+            return (f"ERROR: content too large ({len(content)} chars, "
+                    f"max {MAX_WRITE_CHUNK}). Write in chunks with write_file "
+                    f"then append_file.")
+        p = _safe(path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(content, encoding="utf-8")
+        return f"OK wrote {len(content)} chars to {path} (total {p.stat().st_size} bytes)"
+    except Exception as e:
+        return f"ERROR: {e}"
+
+
+def append_file(path: str, content: str) -> str:
+    """Append text to a file (creates it if missing)."""
+    try:
+        if not isinstance(content, str):
+            return "ERROR: content must be a string"
+        if len(content) > MAX_WRITE_CHUNK:
+            return f"ERROR: chunk too large ({len(content)} chars)"
+        p = _safe(path)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        with p.open("a", encoding="utf-8") as f:
+            f.write(content)
+        return f"OK appended {len(content)} chars; file is now {p.stat().st_size} bytes"
+    except Exception as e:
+        return f"ERROR: {e}"
+
+
+def read_file(path: str) -> str:
+    try:
+        p = _safe(path)
+        if not p.exists():
+            return f"ERROR: not found: {path}"
+        return p.read_text(encoding="utf-8", errors="replace")[:MAX_READ]
+    except Exception as e:
+        return f"ERROR: {e}"
+
+
+def list_dir(path: str = ".") -> str:
+    try:
+        p = _safe(path)
+        if not p.is_dir():
+            return f"ERROR: not a directory: {path}"
+        rows = []
+        for child in sorted(p.iterdir()):
+            kind = "DIR " if child.is_dir() else "FILE"
+            size = child.stat().st_size if child.is_file() else 0
+            rows.append(f"{kind} {size:>9}  {child.name}")
+        return "\n".join(rows) or "(empty)"
+    except Exception as e:
+        return f"ERROR: {e}"
+
+
+TOOL_SCHEMAS = [
+    {"type": "function", "function": {
+        "name": "write_file",
+        "description": (
+            "Create or overwrite a file in the workspace. "
+            "For large files, write the first chunk then use append_file."
+        ),
+        "parameters": {"type": "object",
+                       "properties": {
+                           "path": {"type": "string",
+                                    "description": "Relative path, e.g. 'gta.html'"},
+                           "content": {"type": "string"}},
+                       "required": ["path", "content"]}}},
+    {"type": "function", "function": {
+        "name": "append_file",
+        "description": "Append text to a file in the workspace (creates if missing).",
+        "parameters": {"type": "object",
+                       "properties": {"path": {"type": "string"},
+                                      "content": {"type": "string"}},
+                       "required": ["path", "content"]}}},
+    {"type": "function", "function": {
+        "name": "read_file",
+        "description": "Read a file's text content from the workspace.",
+        "parameters": {"type": "object",
+                       "properties": {"path": {"type": "string"}},
+                       "required": ["path"]}}},
+    {"type": "function", "function": {
+        "name": "list_dir",
+        "description": "List files and folders in a workspace directory.",
+        "parameters": {"type": "object",
+                       "properties": {"path": {"type": "string"}}}}},
+]
+
+TOOL_CALLABLES = {
+    "write_file": write_file,
+    "append_file": append_file,
+    "read_file": read_file,
+    "list_dir": list_dir,
+}

agent_code/data/skills/public_api/skill.md

@@ -0,0 +1,42 @@
+---
+name: public_api
+description: Search free public APIs and call them.
+version: 1.0.0
+author: abdo
+---
+
+# public_api
+
+Search a catalog of 700+ free public APIs and call them directly.
+
+## Source
+
+  https://public-api-lists.github.io/public-api-lists/api/all.json
+
+Cached to %TEMP%/public_apis.json on first use. No auth, no
+rate limit, 48 categories.
+
+## Tools the LLM can call
+
+  search_apis(query, category, no_auth_only, limit)
+      Find APIs matching a keyword or category.
+      no_auth_only=True skips ones that need an API key.
+
+  call_api(url, max_chars)
+      GET a URL and return the first N chars of the body.
+      Use for raw JSON endpoints only.
+
+## Example
+
+  User: find a free API for cat facts and call it
+  Agent:
+    search_apis(query="cat facts")
+      → catfact.ninja | auth=No | https://catfact.ninja/
+    call_api(url="https://catfact.ninja/fact")
+      → {"fact": "An adult lion's roar..."}
+
+## Rules the agent follows
+
+  • Prefer APIs with auth == "No"
+  • Never fabricate URLs — only use ones returned by search
+  • Use the browser for HTML pages, call_api for raw JSON

agent_code/data/skills/public_api/skill.py

@@ -0,0 +1,105 @@
+"""public_api skill — search free public APIs and call them."""
+
+import os
+import json
+from pathlib import Path
+
+SKILL = {
+    "name": "public_api",
+    "description": (
+        "Search free public APIs (weather, crypto, news, animals, etc.) from "
+        "the public-api-lists repo (730+ APIs, 48 categories) and call them."
+    ),
+}
+
+_CATALOG = Path(os.environ.get("TEMP", "/tmp")) / "public_apis.json"
+_CATALOG_URL = "https://public-api-lists.github.io/public-api-lists/api/all.json"
+
+
+def _extract_entries(data):
+    if isinstance(data, list):
+        return [e for e in data if isinstance(e, dict)]
+    if isinstance(data, dict):
+        for k in ("data", "apis", "entries", "items", "results"):
+            if k in data and isinstance(data[k], list):
+                return [e for e in data[k] if isinstance(e, dict)]
+        collected = []
+        for v in data.values():
+            if isinstance(v, list):
+                collected.extend(x for x in v if isinstance(x, dict))
+        return collected
+    return []
+
+
+def _catalog():
+    if not _CATALOG.exists() or _CATALOG.stat().st_size == 0:
+        import urllib.request
+        with urllib.request.urlopen(_CATALOG_URL, timeout=30) as r:
+            _CATALOG.write_bytes(r.read())
+    raw = json.loads(_CATALOG.read_text(encoding="utf-8"))
+    return _extract_entries(raw)
+
+
+def search_apis(query="", category="", no_auth_only=True, limit=10):
+    try:
+        entries = _catalog()
+    except Exception as e:
+        return f"ERROR: {e}"
+    if not entries:
+        return "ERROR: catalog empty or unexpected shape"
+
+    q, c = (query or "").lower().strip(), (category or "").lower().strip()
+    hits = []
+    for e in entries:
+        auth = str(e.get("auth", "")).lower()
+        if no_auth_only and auth not in ("no", "", "none", "false"):
+            continue
+        if c and str(e.get("category", "")).lower() != c:
+            continue
+        if q and q not in str(e.get("name", "")).lower() \
+             and q not in str(e.get("description", "")).lower():
+            continue
+        hits.append(e)
+        if len(hits) >= limit:
+            break
+    if not hits:
+        return "No matches."
+    return "\n".join(
+        f"{e.get('name','?')} | auth={e.get('auth','?')} | {e.get('link','?')}"
+        for e in hits
+    )
+
+
+def call_api(url, max_chars=4000):
+    if not url.startswith(("http://", "https://")):
+        return "ERROR: bad url"
+    try:
+        import urllib.request
+        req = urllib.request.Request(url, headers={"User-Agent": "agent/1.0"})
+        with urllib.request.urlopen(req, timeout=20) as r:
+            return r.read().decode("utf-8", errors="replace")[:max_chars] or "(empty)"
+    except Exception as e:
+        return f"ERROR: {e}"
+
+
+TOOL_SCHEMAS = [
+    {"type": "function", "function": {
+        "name": "search_apis",
+        "description": "Search free public APIs.",
+        "parameters": {"type": "object", "properties": {
+            "query": {"type": "string"},
+            "category": {"type": "string"},
+            "no_auth_only": {"type": "boolean"},
+            "limit": {"type": "integer"}}}}},
+    {"type": "function", "function": {
+        "name": "call_api",
+        "description": "GET a public API URL and return the body.",
+        "parameters": {"type": "object",
+                       "properties": {"url": {"type": "string"}},
+                       "required": ["url"]}}},
+]
+
+TOOL_CALLABLES = {
+    "search_apis": search_apis,
+    "call_api": call_api,
+}

agent_code/data/skills/temp_mail/skill.md

@@ -0,0 +1,51 @@
+---
+name: temp_mail
+description: Temporary email with multi-provider send and receive.
+version: 1.0.0
+author: abdo
+---
+
+# temp_mail
+
+Temporary email that can both receive and send.
+
+## Receive chain (tries in order)
+
+  mail.tm          REST API, no signup, no captcha
+  Guerrilla Mail   AJAX, receive only
+  PhoboMail        MCP-based, send + receive
+
+## Send (configure one with /email)
+
+  Resend    100/day, 3000/mo    https://resend.com
+  Brevo     300/day, 9000/mo    https://brevo.com
+  Mailjet   200/day, 6000/mo    https://mailjet.com
+
+The temp inbox address is attached as Reply-To on every send,
+so replies land back in check_temp_inbox().
+
+## Tools the LLM can call
+
+  get_temp_email       create or return the temp address
+  send_email           send from the temp address
+  check_temp_inbox     list received messages
+  read_temp_email      read one by ID
+  reset_temp_email     rotate to a fresh address
+  list_providers       show all send + receive providers
+
+## Commands you can type
+
+  /email                    show current status
+  /email resend  <key>
+  /email brevo   <key> <from@addr>
+  /email mailjet <user> <secret> <from@addr>
+  /providers                list all providers
+
+## Setup (30 seconds)
+
+  1. Sign up free at https://resend.com (no card)
+  2. Copy your API key (starts with re_)
+  3. In chat:   /email resend re_YOUR_KEY
+  4. Try:       send hi to someone@example.com
+
+Do NOT retry send_email before /email is configured.