openclay-agent 2.0.0__tar.gz

openclay_agent-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anomalia
+
+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.

openclay_agent-2.0.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: openclay-agent
+Version: 2.0.0
+Summary: Turn intention into infrastructure. Local-first AI agent bootstrapper.
+Author-email: Anomalia <openclay@proton.me>
+License: MIT
+Project-URL: Homepage, https://github.com/openclay1/OpenClay
+Project-URL: Repository, https://github.com/openclay1/OpenClay
+Keywords: ai,agent,local,wiki,llm,ollama,infrastructure
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gradio>=4.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: tweepy>=4.14.0
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40.0; extra == "anthropic"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: all
+Requires-Dist: anthropic>=0.40.0; extra == "all"
+Requires-Dist: openai>=1.0.0; extra == "all"
+Dynamic: license-file
+
+# 🏺 OpenClay — turn intention into infrastructure.
+
+You describe what you want. OpenClay reads your machine, builds a local AI stack, and starts working. No config files. No copy-paste. Everything it learns about you stays on your computer, in files you own.
+
+<!-- TODO: replace with actual GIF -->
+![OpenClay demo](https://via.placeholder.com/800x400?text=demo+GIF+goes+here)
+
+```bash
+pip install openclay-agent
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/openclay1/OpenClay.git && cd OpenClay && pip3 install -r requirements.txt && python3 app.py
+```
+
+| Your hardware | What OpenClay runs |
+|---|---|
+| 32 GB+ RAM, Apple Silicon / 6 GB+ VRAM | `llama3:8b` — full reasoning |
+| 16 GB+ RAM, Apple Silicon / CUDA | `qwen2.5:7b` — fast + capable |
+| 16 GB+ RAM, Intel, no discrete GPU | `qwen2.5:3b-instruct-q4_K_M` — lean workhorse |
+| 8 GB+ RAM | `qwen2.5:1.5b` — lightweight |
+| Under 8 GB | Template-only mode — no model needed |
+| Any machine + API key | Claude, GPT-4, etc. via config |
+
+---
+
+## What it does today
+
+- **Single input, single button.** Type an intention, hit Go.
+- **Hardware detection → model selection → silent install.** You don't pick a model. It does.
+- **LLM Wiki.** Karpathy-pattern knowledge base. Ingest files, query your wiki, lint for health. Local markdown, yours forever.
+- **Tweet drafting and posting.** Draft from intention, review, post — or post directly.
+- **Persistent memory.** AGENTS.md tracks what works, what fails, your preferences. The agent reads it before every action.
+
+## How it works
+
+```
+intention → hardware scan → model install → execution → wiki memory
+```
+
+Everything runs locally through Ollama. No data leaves your machine.
+
+## Wiki
+
+OpenClay maintains a local wiki that compounds over time. Drop a file in `raw/`, type `ingest filename`, and the LLM breaks it into concept pages, entity pages, and source summaries. Query it later. Lint it for contradictions.
+
+```
+raw/              ← your files, immutable, LLM never writes here
+wiki/
+  concepts/       ← idea pages
+  entities/       ← people, orgs, tools
+  sources/        ← one summary per ingested file
+  comparisons/    ← cross-source analysis
+  index.md        ← auto-generated catalog
+  log.md          ← append-only activity record
+```
+
+The wiki is not for you. It's for the agent — so it can act with consistency.
+
+## Configuration
+
+```bash
+cp .env.example .env
+```
+
+Most things work with zero config. Add Twitter keys only if you want to post.
+
+## Project structure
+
+```
+app.py              — entry point
+panel.py            — browser UI (Gradio)
+agent_backend.py    — switchable LLM backend
+wiki_engine.py      — wiki operations: ingest, query, lint
+memory.py           — AGENTS.md persistent memory
+twitter_post.py     — tweet posting (Tweepy)
+introspect.py       — hardware detection
+theme.css           — design system
+openclay.md         — wiki schema
+wiki/               — agent's compounding memory
+raw/                — immutable source documents
+```
+
+Every module stays under 300 lines.
+
+## Principles
+
+1. **Act, don't ask.** If the agent can do it, it does it.
+2. **Local-first.** No cloud dependency for core function.
+3. **Files over apps.** Markdown you own, not data locked in a platform.
+4. **Install what's missing.** Silent. No questions.
+
+## License
+
+MIT — it's yours.
+
+[github.com/openclay1/OpenClay](https://github.com/openclay1/OpenClay)

openclay_agent-2.0.0/README.md

@@ -0,0 +1,99 @@
+# 🏺 OpenClay — turn intention into infrastructure.
+
+You describe what you want. OpenClay reads your machine, builds a local AI stack, and starts working. No config files. No copy-paste. Everything it learns about you stays on your computer, in files you own.
+
+<!-- TODO: replace with actual GIF -->
+![OpenClay demo](https://via.placeholder.com/800x400?text=demo+GIF+goes+here)
+
+```bash
+pip install openclay-agent
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/openclay1/OpenClay.git && cd OpenClay && pip3 install -r requirements.txt && python3 app.py
+```
+
+| Your hardware | What OpenClay runs |
+|---|---|
+| 32 GB+ RAM, Apple Silicon / 6 GB+ VRAM | `llama3:8b` — full reasoning |
+| 16 GB+ RAM, Apple Silicon / CUDA | `qwen2.5:7b` — fast + capable |
+| 16 GB+ RAM, Intel, no discrete GPU | `qwen2.5:3b-instruct-q4_K_M` — lean workhorse |
+| 8 GB+ RAM | `qwen2.5:1.5b` — lightweight |
+| Under 8 GB | Template-only mode — no model needed |
+| Any machine + API key | Claude, GPT-4, etc. via config |
+
+---
+
+## What it does today
+
+- **Single input, single button.** Type an intention, hit Go.
+- **Hardware detection → model selection → silent install.** You don't pick a model. It does.
+- **LLM Wiki.** Karpathy-pattern knowledge base. Ingest files, query your wiki, lint for health. Local markdown, yours forever.
+- **Tweet drafting and posting.** Draft from intention, review, post — or post directly.
+- **Persistent memory.** AGENTS.md tracks what works, what fails, your preferences. The agent reads it before every action.
+
+## How it works
+
+```
+intention → hardware scan → model install → execution → wiki memory
+```
+
+Everything runs locally through Ollama. No data leaves your machine.
+
+## Wiki
+
+OpenClay maintains a local wiki that compounds over time. Drop a file in `raw/`, type `ingest filename`, and the LLM breaks it into concept pages, entity pages, and source summaries. Query it later. Lint it for contradictions.
+
+```
+raw/              ← your files, immutable, LLM never writes here
+wiki/
+  concepts/       ← idea pages
+  entities/       ← people, orgs, tools
+  sources/        ← one summary per ingested file
+  comparisons/    ← cross-source analysis
+  index.md        ← auto-generated catalog
+  log.md          ← append-only activity record
+```
+
+The wiki is not for you. It's for the agent — so it can act with consistency.
+
+## Configuration
+
+```bash
+cp .env.example .env
+```
+
+Most things work with zero config. Add Twitter keys only if you want to post.
+
+## Project structure
+
+```
+app.py              — entry point
+panel.py            — browser UI (Gradio)
+agent_backend.py    — switchable LLM backend
+wiki_engine.py      — wiki operations: ingest, query, lint
+memory.py           — AGENTS.md persistent memory
+twitter_post.py     — tweet posting (Tweepy)
+introspect.py       — hardware detection
+theme.css           — design system
+openclay.md         — wiki schema
+wiki/               — agent's compounding memory
+raw/                — immutable source documents
+```
+
+Every module stays under 300 lines.
+
+## Principles
+
+1. **Act, don't ask.** If the agent can do it, it does it.
+2. **Local-first.** No cloud dependency for core function.
+3. **Files over apps.** Markdown you own, not data locked in a platform.
+4. **Install what's missing.** Silent. No questions.
+
+## License
+
+MIT — it's yours.
+
+[github.com/openclay1/OpenClay](https://github.com/openclay1/OpenClay)

openclay_agent-2.0.0/agent_backend.py

@@ -0,0 +1,300 @@
+"""agent_backend.py — Switchable agent backend (clawcode / claudecode via Ollama)."""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+from pathlib import Path
+
+import urllib.request
+
+try:
+    import requests
+except ImportError:
+    requests = None
+
+BASE_DIR = Path(__file__).parent
+DATA_DIR = BASE_DIR / "data"
+ENV_PATH = BASE_DIR / ".env"
+OLLAMA_URL = "http://localhost:11434"
+
+# ── Tools available to the Claw Code agent loop ──
+AGENT_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "write_file",
+            "description": "Write content to a file at the given path.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "File path"},
+                    "content": {"type": "string", "description": "File content"},
+                },
+                "required": ["path", "content"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Read a file and return its contents.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "File path"},
+                },
+                "required": ["path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_command",
+            "description": "Run a shell command and return stdout.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "Shell command"},
+                },
+                "required": ["command"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "list_files",
+            "description": "List files in a directory.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "Directory path"},
+                },
+                "required": ["path"],
+            },
+        },
+    },
+]
+
+
+def _read_env_key(key: str) -> str:
+    """Read a key from .env, fall back to os.environ."""
+    if ENV_PATH.exists():
+        for line in ENV_PATH.read_text().splitlines():
+            l = line.strip()
+            if l and not l.startswith("#") and "=" in l:
+                k, _, v = l.partition("=")
+                if k.strip() == key:
+                    return v.strip()
+    return os.environ.get(key, "")
+
+
+def get_backend() -> str:
+    """Return the configured backend: 'clawcode' or 'claudecode'."""
+    val = _read_env_key("AGENT_BACKEND").lower().strip()
+    if val in ("clawcode", "claw", "claw-code", "claw_code"):
+        return "clawcode"
+    return "claudecode"
+
+
+def get_model() -> str:
+    """Return the configured Ollama model name."""
+    stack_path = DATA_DIR / "stack.json"
+    if stack_path.exists():
+        with open(stack_path) as f:
+            stack = json.load(f)
+        return stack.get("model", {}).get("model", "qwen2.5:3b-instruct-q4_K_M")
+    return "qwen2.5:3b-instruct-q4_K_M"
+
+
+# ── Tool executors (sandboxed to project directory) ──
+
+def _exec_tool(name: str, args: dict) -> str:
+    """Execute a tool call and return the result string."""
+    if name == "write_file":
+        p = Path(args["path"])
+        if not str(p.resolve()).startswith(str(BASE_DIR)):
+            return "Error: path outside project directory"
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(args["content"])
+        return f"Written {len(args['content'])} chars to {p}"
+    elif name == "read_file":
+        p = Path(args["path"])
+        if not p.exists():
+            return f"Error: {p} not found"
+        return p.read_text()[:4000]
+    elif name == "run_command":
+        try:
+            r = subprocess.run(
+                args["command"], shell=True, capture_output=True,
+                text=True, timeout=30, cwd=str(BASE_DIR))
+            return (r.stdout + r.stderr)[:4000]
+        except subprocess.TimeoutExpired:
+            return "Error: command timed out (30s)"
+    elif name == "list_files":
+        p = Path(args.get("path", str(BASE_DIR)))
+        if p.is_dir():
+            return "\n".join(f.name for f in sorted(p.iterdir())[:50])
+        return f"Error: {p} is not a directory"
+    return f"Error: unknown tool {name}"
+
+
+# ── Shared: urllib fallback for when requests is unavailable ──
+
+def _ollama_chat_urllib(prompt: str, model: str) -> str:
+    """Simple /api/chat call using only urllib (no tool use)."""
+    payload = json.dumps({
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "stream": False,
+    }).encode()
+    try:
+        req = urllib.request.Request(
+            f"{OLLAMA_URL}/api/chat", data=payload,
+            headers={"Content-Type": "application/json"})
+        resp = urllib.request.urlopen(req, timeout=120)
+        data = json.loads(resp.read())
+        return data.get("message", {}).get("content", "")
+    except Exception:
+        return ""
+
+
+def _ollama_post(url: str, body: dict, timeout: int = 120) -> dict | None:
+    """POST to Ollama using requests or urllib."""
+    if requests:
+        try:
+            r = requests.post(url, json=body, timeout=timeout)
+            return r.json() if r.status_code == 200 else None
+        except Exception:
+            return None
+    # urllib fallback
+    payload = json.dumps(body).encode()
+    try:
+        req = urllib.request.Request(
+            url, data=payload, headers={"Content-Type": "application/json"})
+        resp = urllib.request.urlopen(req, timeout=timeout)
+        return json.loads(resp.read())
+    except Exception:
+        return None
+
+
+# ── Claw Code backend: Ollama /api/chat with tool-use loop ──
+
+def _clawcode_generate(prompt: str, model: str, max_turns: int = 5) -> str:
+    """Claw Code style agent loop: chat + tool calls over Ollama."""
+    messages = [{"role": "user", "content": prompt}]
+    content = ""
+
+    for _ in range(max_turns):
+        data = _ollama_post(f"{OLLAMA_URL}/api/chat", {
+            "model": model, "messages": messages,
+            "tools": AGENT_TOOLS, "stream": False,
+        })
+        if not data:
+            return _claudecode_generate(prompt, model)
+
+        msg = data.get("message", {})
+        content = msg.get("content", "")
+        tool_calls = msg.get("tool_calls", [])
+
+        if not tool_calls:
+            return content
+
+        messages.append(msg)
+        for tc in tool_calls:
+            fn = tc.get("function", {})
+            name = fn.get("name", "")
+            args = fn.get("arguments", {})
+            if isinstance(args, str):
+                try:
+                    args = json.loads(args)
+                except json.JSONDecodeError:
+                    args = {}
+            result = _exec_tool(name, args)
+            messages.append({"role": "tool", "content": result})
+
+    return content if content else "Agent completed (max turns reached)."
+
+
+# ── Claude Code backend: simple Ollama CLI generate ──
+
+def _find_ollama() -> str:
+    """Find the ollama binary path."""
+    for p in ["/usr/local/bin/ollama", "/opt/homebrew/bin/ollama", "ollama"]:
+        if Path(p).exists() or p == "ollama":
+            return p
+    return "ollama"
+
+
+def _claudecode_generate(prompt: str, model: str) -> str:
+    """Original simple path: ollama run via subprocess."""
+    ollama = _find_ollama()
+    try:
+        result = subprocess.run(
+            [ollama, "run", model, prompt],
+            capture_output=True, text=True, timeout=120,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    # Fallback: use urllib if subprocess fails
+    return _ollama_chat_urllib(prompt, model)
+
+
+# ── Public API ──
+
+def _inject_memory(prompt: str) -> str:
+    """Prepend AGENTS.md context to the prompt if available."""
+    try:
+        from memory import load_memory_context
+        ctx = load_memory_context()
+        if ctx:
+            return f"AGENT MEMORY:\n{ctx}\n\n---\n\n{prompt}"
+    except Exception:
+        pass
+    return prompt
+
+
+def generate(prompt: str, model: str | None = None) -> str:
+    """Generate text using the configured backend.
+
+    Reads AGENTS.md before every call. Logs outcome after.
+    This is the single entry point all modules should use.
+    """
+    if model is None:
+        model = get_model()
+    backend = get_backend()
+    full_prompt = _inject_memory(prompt)
+    try:
+        if backend == "clawcode":
+            result = _clawcode_generate(full_prompt, model)
+        else:
+            result = _claudecode_generate(full_prompt, model)
+        # Silent success logging
+        try:
+            from memory import record_success
+            short = prompt[:80].replace("\n", " ")
+            record_success(f"generate({backend})", model, short)
+        except Exception:
+            pass
+        return result
+    except Exception as e:
+        # Silent failure logging
+        try:
+            from memory import record_failure
+            record_failure(f"generate({backend})", str(e)[:200])
+        except Exception:
+            pass
+        raise
+
+
+def generate_with_tools(prompt: str, model: str | None = None,
+                        max_turns: int = 5) -> str:
+    """Force the tool-use agent loop regardless of backend setting."""
+    if model is None:
+        model = get_model()
+    return _clawcode_generate(prompt, model, max_turns=max_turns)

openclay_agent-2.0.0/app.py

@@ -0,0 +1,106 @@
+"""
+app.py — OpenClay entry point.
+Detects hardware, installs what's needed, opens the browser.
+"""
+
+import json
+import os
+import sys
+import threading
+import time
+from pathlib import Path
+
+BASE_DIR = Path(__file__).parent
+DATA_DIR = BASE_DIR / "data"
+QUEUE_DIR = BASE_DIR / "queue"
+CONFIG_PATH = BASE_DIR / "config.json"
+
+os.chdir(str(BASE_DIR))
+sys.path.insert(0, str(BASE_DIR))
+
+
+def load_config() -> dict:
+    if CONFIG_PATH.exists():
+        with open(CONFIG_PATH) as f:
+            return json.load(f)
+    return {}
+
+
+def setup():
+    """Detect hardware, write to memory, install silently."""
+    # Hardware detection
+    profile = {}
+    try:
+        from introspect import run as introspect_run
+        profile = introspect_run()
+    except Exception:
+        pass
+
+    # Write machine profile to AGENTS.md (first run populates, later runs update)
+    try:
+        from memory import record_machine_profile
+        record_machine_profile(profile)
+    except Exception:
+        pass
+
+    # Stack selection
+    try:
+        from selector import run as selector_run
+        stack = selector_run()
+    except Exception:
+        stack = {}
+
+    # Silent installation
+    try:
+        from installer import run as installer_run
+        installer_run()
+    except Exception:
+        pass
+
+    return stack
+
+
+def main():
+    print("OpenClay is starting... ⚡")
+    config = load_config()
+    demo = config.get("demo_mode", False)
+
+    # Demo mode: load sample intent
+    if demo:
+        demo_path = BASE_DIR / config.get("demo_asset", "demo_assets/sample_intake.json")
+        if demo_path.exists():
+            DATA_DIR.mkdir(parents=True, exist_ok=True)
+            QUEUE_DIR.mkdir(parents=True, exist_ok=True)
+            with open(demo_path) as f:
+                intent = json.load(f)
+            with open(DATA_DIR / "intent.json", "w") as f:
+                json.dump(intent, f, indent=2)
+
+    # Setup: hardware + install (silent)
+    stack = setup()
+
+    # Start agent loop in background
+    try:
+        from agent import run_loop
+        agent_thread = threading.Thread(target=run_loop, daemon=True)
+        agent_thread.start()
+    except Exception:
+        pass
+
+    # One clean line, then open the browser
+    print("\n  ✓ OpenClay ready → http://127.0.0.1:7861\n")
+
+    # Launch panel (blocks)
+    try:
+        from panel import launch
+        launch()
+    except ImportError:
+        print("  Gradio not installed. Run: pip3 install gradio")
+    except KeyboardInterrupt:
+        print("\n  Stopped.")
+    except Exception as e:
+        print(f"  Error: {e}")
+
+
+if __name__ == "__main__":
+    main()