Migrated from GitHub

Dockerfile

@@ -0,0 +1,73 @@
+# ----------------------------
+# PygmyClaw Dockerfile
+# ----------------------------
+FROM ubuntu:22.04
+
+ENV DEBIAN_FRONTEND=noninteractive
+# Dockerfile snippet
+ENV MODEL_NAME="hf.co/rahul7star/Qwen3-4B-Thinking-2509-Genius-Coder-AI-Full:Q5_K_M"
+ENV OLLAMA_HOST="0.0.0.0:11434"
+ENV PYTHONUNBUFFERED=1
+
+# ----------------------------
+# Install system dependencies
+# ----------------------------
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libcurl4-openssl-dev \
+    libcjson-dev \
+    curl \
+    python3 \
+    python3-pip \
+    git \
+    zstd \
+    sudo \
+    && rm -rf /var/lib/apt/lists/*
+
+# ----------------------------
+# Install Ollama
+# ----------------------------
+RUN curl -fsSL https://ollama.com/install.sh | sh
+
+# ----------------------------
+# Python dependencies
+# ----------------------------
+RUN pip3 install --upgrade pip \
+    && pip3 install \
+        streamlit \
+        gradio==4.44.0 \
+        huggingface_hub==0.23.5 \
+        requests \
+        redis \
+        huggingface_hub \
+        torch \
+        torchvision \
+        torchaudio
+
+# ----------------------------
+# Set working directory
+# ----------------------------
+WORKDIR /workspace
+
+# ----------------------------
+# Copy the PygmyClaw repo
+# ----------------------------
+COPY . /workspace/
+
+# ----------------------------
+# Ensure scripts are executable
+# ----------------------------
+RUN chmod +x /workspace/entrypoint.sh \
+    && chmod +x /workspace/pygmyclaw.py \
+    && chmod +x /workspace/pygmyclaw_multitool.py \
+    && mkdir -p /workspace/data
+
+# ----------------------------
+# Expose UI port for Gradio / Streamlit
+# ----------------------------
+EXPOSE 7860
+
+# ----------------------------
+# Entrypoint
+# ----------------------------
+CMD ["/workspace/entrypoint.sh"]

ORIGINAL_README.md

@@ -0,0 +1,10 @@
+---
+title: Pyclaw
+emoji: 🐠
+colorFrom: pink
+colorTo: blue
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

acchite.md

@@ -0,0 +1,226 @@
+
+---
+
+# 🦾 PygmyClaw Autonomous Agent — End-to-End Design
+
+## 1. **Overview**
+
+PygmyClaw is a compact AI agent framework designed for **dynamic Python tool execution, speculative decoding, and autonomous task handling**.
+With Hugging Face integration, it can now **store persistent memory, code, and artifacts**, evolving toward a fully autonomous agent like Claude.
+
+**Key goals:**
+
+* Execute Python code dynamically with dependency management.
+* Generate, edit, and run code via UI.
+* Maintain long-term memory and datasets in Hugging Face.
+* Handle autonomous multi-step workflows with multi-instance speculative decoding.
+
+---
+
+## 2. **System Components**
+
+### 2.1 User Interface
+
+* Streamlit-based web UI.
+* **Features:**
+
+  * Prompt input
+  * `/HELP` commands
+  * Code generation `/WRITE_PY`
+  * Code editing + execution (`CPU` or optional `GPU`)
+  * Book, story, or poem management
+  * Session logs and downloads
+
+---
+
+### 2.2 Agent Core — `pygmyclaw.py`
+
+* Handles all **user-agent interaction**:
+
+  * Receives user prompts.
+  * Converts LLM output into **JSON tool calls**.
+  * Dynamically loads and executes Python tools.
+* **Speculative decoding**:
+
+  * 3 drafters + 1 verifier for robust output.
+* **Queue system**:
+
+  * Redis or JSON-file queue for task scheduling.
+* **Artifact management**:
+
+  * Stores code, logs, and task outputs in workspace.
+  * Supports automatic dependency installation.
+
+---
+
+### 2.3 Python Multitool — `pygmyclaw_multitool.py`
+
+* **Tool registry**:
+
+  * `list_tools_detailed`, `sys_info`, `log_error`, `echo`, etc.
+* **Dynamic tool addition**:
+
+  * Agents can create new tools that are callable via JSON.
+* **Safe execution sandbox**:
+
+  * Python subprocess with controlled input/output.
+
+---
+
+### 2.4 LLM Interaction
+
+* **Ollama / HF-hosted model** as backend:
+
+  * Multi-instance support for **parallel drafters**.
+  * Token-based speculative decoding.
+* **Workflow**:
+
+  ```
+  User prompt
+      ↓
+  Agent (LLM)
+      ↓
+  JSON tool call
+      ↓
+  Python tool executes
+      ↓
+  Result returned to LLM
+      ↓
+  Final response to user
+  ```
+* **Dynamic code generation & execution** integrated:
+
+  * e.g., user asks for PyTorch demo → agent installs PyTorch → generates editable code → runs it in UI.
+
+---
+
+### 2.5 Persistent Memory — Hugging Face
+
+* **Repository:** `rahul7star/pyclaw`
+* **Stores:**
+
+  * Generated code & scripts
+  * Task outputs (`.out`)
+  * Logs & session history
+  * Dynamic tools and metadata
+* **Mechanism:**
+
+  * Push artifacts via `huggingface_hub` API
+  * Pull existing artifacts for agent memory
+* **Benefits:** Enables **long-term learning**, cross-session continuity, and reproducibility.
+
+---
+
+### 2.6 Autonomous Task Management
+
+* **Queue-based execution**:
+
+  * Tasks added by user or agent itself.
+  * Background processor executes tasks in order.
+* **Speculative execution**:
+
+  * Multi-instance drafters improve code reliability.
+  * Verifier ensures correctness of outputs.
+* **Dynamic tools**:
+
+  * Tools can evolve or new tools can be created on-the-fly.
+
+---
+
+### 2.7 Safety & Resource Management
+
+* **Code execution sandbox**:
+
+  * Controlled Python subprocess.
+  * Auto cleanup of temporary files.
+* **CPU/GPU selection**:
+
+  * Default: CPU
+  * Optional: GPU if available and environment variable set.
+* **Dependency management**:
+
+  * Automatic package installation (e.g., PyTorch for user-requested demos).
+
+---
+
+## 3. **Example User Workflow**
+
+**User Prompt:**
+`"Create a neural network demo in Python using PyTorch."`
+
+**Agent Actions:**
+
+1. Detects PyTorch requirement → installs on CPU.
+2. Generates Python code using `/WRITE_PY`.
+3. Saves code in Hugging Face repo for memory.
+4. Displays code in UI for editing.
+5. Runs code → outputs printed and logged.
+6. Updates agent memory with results and execution logs.
+7. Optionally creates a new dynamic tool for future NN generation.
+
+---
+
+## 4. **Evolvable Architecture**
+
+| Feature                   | Current Status | Future Evolution                                     |
+| ------------------------- | -------------- | ---------------------------------------------------- |
+| Dynamic Tool Creation     | ✅              | Can auto-generate new tools from tasks               |
+| Long-Term Memory          | ✅ via HF       | Add semantic search, embeddings for context          |
+| Speculative Decoding      | ✅              | Increase drafters, multi-agent cooperation           |
+| Autonomous Task Execution | Partial        | Recursive task planning, multi-step project handling |
+| Dependency Management     | ✅              | Expand to virtual environments per project           |
+| Safe Execution            | Partial        | Containerized execution (Docker/WSL)                 |
+
+---
+
+## 5. **Roadmap to Claude-Like Autonomy**
+
+1. **Enhance memory:** Semantic embeddings + search in HF repo.
+2. **Recursive reasoning:** Agent generates subtasks autonomously.
+3. **Multi-agent collaboration:** Multiple PygmyClaws coordinate on large projects.
+4. **Learning from outputs:** Store completed tasks + feedback for continuous improvement.
+5. **Safety & isolation:** Dockerized Python execution with resource limits.
+6. **Dynamic UI:** Allow live editing, execution, and visualization of code outputs.
+
+---
+
+## 6. **Diagram of End-to-End Flow**
+
+```
+           ┌───────────────┐
+           │   User Prompt │
+           └───────┬───────┘
+                   │
+                   ▼
+           ┌───────────────┐
+           │  Agent (LLM)  │
+           └───────┬───────┘
+                   │ JSON Tool Call
+                   ▼
+           ┌───────────────┐
+           │ Python Tool   │
+           │ Executes Task │
+           └───────┬───────┘
+                   │ Result
+                   ▼
+           ┌───────────────┐
+           │  Agent (LLM)  │
+           │ Processes     │
+           └───────┬───────┘
+                   │
+                   ▼
+           ┌───────────────┐
+           │   UI Output   │
+           │ (Code/Result) │
+           └───────┬───────┘
+                   │
+                   ▼
+           ┌───────────────┐
+           │ │
+           │ Persistent    │
+           │ Memory Repo   │
+           └───────────────┘
+```
+
+---
+

app.py

@@ -0,0 +1,238 @@
+import streamlit as st
+import re
+import uuid
+import subprocess
+import sys
+from datetime import datetime
+from threading import Thread
+from queue import Queue
+from pygmyclaw import PygmyClaw
+
+st.set_page_config(page_title="Py", layout="wide")
+
+# --------------------------------------------------
+# GLOBAL STATE
+# --------------------------------------------------
+
+if "job_store" not in st.session_state:
+    st.session_state.job_store = {}
+
+if "job_queue" not in st.session_state:
+    st.session_state.job_queue = Queue()
+
+if "agent" not in st.session_state:
+    st.session_state.agent = PygmyClaw()
+
+if "worker_started" not in st.session_state:
+    st.session_state.worker_started = False
+
+job_store = st.session_state.job_store
+job_queue = st.session_state.job_queue
+agent = st.session_state.agent
+
+
+# --------------------------------------------------
+# BACKGROUND WORKER
+# --------------------------------------------------
+
+def worker():
+    while True:
+        job_id = job_queue.get()
+        job = job_store[job_id]
+        job["status"] = "running"
+        try:
+            system_prompt = f"""
+You are a Python coding assistant.
+
+Return ONLY runnable Python code.
+Do NOT explain anything.
+
+Task:
+{job['prompt']}
+"""
+            result = agent.submit_prompt(system_prompt, job["tool"])
+
+            # ===== FIX =====
+            match = re.search(r"```python(.*?)```", result, re.S)
+            if match:
+                code = match.group(1).strip()
+            else:
+                code = result.strip()
+            # ===============
+
+            job["response"] = result
+            job["code"] = code
+            job["status"] = "completed"
+
+        except Exception as e:
+            job["status"] = "failed"
+            job["response"] = str(e)
+
+        job_queue.task_done()
+
+# --------------------------------------------------
+# START WORKER
+# --------------------------------------------------
+
+if not st.session_state.worker_started:
+
+    Thread(target=worker, daemon=True).start()
+
+    st.session_state.worker_started = True
+
+
+# --------------------------------------------------
+# HEADER
+# --------------------------------------------------
+
+st.title("🧠 PygmyClaw AI Dev Dashboard")
+
+# --------------------------------------------------
+# CREATE TASK
+# --------------------------------------------------
+
+with st.expander("🚀 Create AI Task", expanded=True):
+
+    col1, col2 = st.columns([4,1])
+
+    prompt = col1.text_area(
+        "Prompt",
+        height=120,
+        placeholder="write a python function to add two numbers",
+        value="write a python function to add two numbers"
+    )
+
+    tool = col2.selectbox(
+        "Tool",
+        ["AI Agent"]
+    )
+
+    if col2.button("Create Job"):
+
+        job_id = str(uuid.uuid4())[:8]
+
+        job_store[job_id] = {
+            "prompt": prompt,
+            "tool": tool,
+            "status": "queued",
+            "response": "",
+            "code": "",
+            "created": datetime.now().strftime("%H:%M:%S")
+        }
+
+        job_queue.put(job_id)
+
+        st.success(f"Job {job_id} queued")
+
+
+# --------------------------------------------------
+# METRICS
+# --------------------------------------------------
+
+queued = sum(1 for j in job_store.values() if j["status"] == "queued")
+running = sum(1 for j in job_store.values() if j["status"] == "running")
+done = sum(1 for j in job_store.values() if j["status"] == "completed")
+failed = sum(1 for j in job_store.values() if j["status"] == "failed")
+
+col1, col2, col3, col4 = st.columns(4)
+
+col1.metric("Queued", queued)
+col2.metric("Running", running)
+col3.metric("Completed", done)
+col4.metric("Failed", failed)
+
+st.divider()
+
+# --------------------------------------------------
+# JOB DASHBOARD
+# --------------------------------------------------
+
+if not job_store:
+    st.info("No jobs yet")
+
+for job_id, job in list(job_store.items())[::-1]:
+
+    with st.container():
+
+        st.subheader(f"Job {job_id}")
+
+        st.write("Status:", job["status"])
+        st.write("Created:", job["created"])
+
+        st.code(job["prompt"], language="text")
+
+        # -----------------------
+        # AI RESPONSE
+        # -----------------------
+
+        if job.get("response"):
+
+            st.markdown("### 🤖 AI Response")
+
+            st.write(job["response"])
+
+        # -----------------------
+        # CODE EDITOR (ALWAYS VISIBLE)
+        # -----------------------
+
+        st.markdown("### 💻 Generated Code")
+
+        job["code"] = st.text_area(
+            "Edit Code",
+            value=job.get("code", ""),
+            height=220,
+            key=f"code_{job_id}"
+        )
+
+        col1, col2 = st.columns(2)
+
+        # -----------------------
+        # RUN CODE
+        # -----------------------
+
+        if col1.button("▶ Run Code", key=f"run_{job_id}"):
+
+            try:
+
+                code = job.get("code", "")
+
+                # detect imports
+                imports = re.findall(
+                    r"^\s*(?:import|from)\s+([\w_]+)",
+                    code,
+                    flags=re.MULTILINE
+                )
+
+                # auto install missing packages
+                for pkg in imports:
+                    try:
+                        __import__(pkg)
+                    except ImportError:
+                        subprocess.run(
+                            [sys.executable, "-m", "pip", "install", pkg],
+                            check=True
+                        )
+
+                local_vars = {}
+
+                exec(code, {}, local_vars)
+
+                st.success("Execution Output")
+
+                st.json(local_vars)
+
+            except Exception as e:
+
+                st.error(str(e))
+
+        # -----------------------
+        # DELETE JOB
+        # -----------------------
+
+        if col2.button("Delete Job", key=f"del_{job_id}"):
+
+            del job_store[job_id]
+
+            st.rerun()
+
+        st.divider()

app_gradio.py

@@ -0,0 +1,212 @@
+# app_gradio.py
+import gradio as gr
+import re
+import uuid
+import time
+import contextlib
+from io import StringIO
+from threading import Thread
+from queue import Queue
+from pygmyclaw import PygmyClaw
+
+# --------------------------------------------------
+# GLOBAL STATE
+# --------------------------------------------------
+job_store = {}
+job_queue = Queue()
+agent = PygmyClaw()
+auto_refresh_enabled = True  # toggle for auto-refresh
+
+# --------------------------------------------------
+# HELPER FUNCTIONS
+# --------------------------------------------------
+def clean_code(code):
+    """Remove markdown fences and normalize code indentation."""
+    if not code:
+        return ""
+    code = re.sub(r"```python", "", code)
+    code = re.sub(r"```", "", code)
+    return code.strip()
+
+def extract_explanation(full_result):
+    """Get explanation text from full AI response."""
+    text_no_code = re.sub(r"```.*?```", "", full_result, flags=re.S)
+    return text_no_code.strip()
+
+def extract_code(full_result):
+    """Extract Python code blocks from full AI response."""
+    code_blocks = re.findall(r"```(?:python)?\s*(.*?)```", full_result, re.S | re.I)
+    code = "\n\n".join([c.strip() for c in code_blocks])
+    return code
+
+# --------------------------------------------------
+# BACKGROUND WORKER
+# --------------------------------------------------
+def worker():
+    """Process queued jobs with AI agent, extract code and explanation."""
+    while True:
+        job_id = job_queue.get()
+        job = job_store[job_id]
+        job["status"] = "running"
+
+        try:
+            prompt = job["prompt"]
+            tool = job["tool"]
+
+            # System prompt
+            system_prompt = f"Write Python code ONLY and explain all lines clearly in comments. Task: {prompt}"
+
+            # Get fresh AI response
+            full_result = agent.generate_with_ssd(system_prompt, timeout=120)
+
+            # Extract code & explanation from response
+            code = extract_code(full_result)
+            explanation = extract_explanation(full_result)
+
+            # Update job
+            job["raw_result"] = full_result
+            job["code"] = code
+            job["response"] = explanation
+            job["status"] = "completed"
+
+        except Exception as e:
+            job["status"] = "failed"
+            job["response"] = str(e)
+        finally:
+            job_queue.task_done()
+
+# Start background worker
+Thread(target=worker, daemon=True).start()
+
+# --------------------------------------------------
+# JOB OPERATIONS
+# --------------------------------------------------
+def create_job(prompt, tool):
+    job_id = str(uuid.uuid4())[:8]
+    job_store[job_id] = {
+        "prompt": prompt,
+        "tool": tool,
+        "status": "queued",
+        "response": "",
+        "code": "",
+        "raw_result": "",
+        "created": time.strftime("%H:%M:%S")
+    }
+    job_queue.put(job_id)
+    return f"Job {job_id} queued", job_id
+
+def dashboard():
+    rows = []
+    for job_id, job in reversed(list(job_store.items())):
+        rows.append([job_id, job["status"], job["created"], job["prompt"], job.get("code", "")])
+    return rows
+
+def load_job(job_id):
+    job = job_store.get(job_id)
+    if not job:
+        return "", "", "", ""
+    return (
+        job.get("prompt", ""),
+        job.get("response", ""),
+        job.get("code", ""),  # editable code
+        job.get("status", "")
+    )
+
+def run_code(code):
+    try:
+        code = clean_code(code)
+        output_buffer = StringIO()
+        with contextlib.redirect_stdout(output_buffer):
+            exec(code, {})
+        result = output_buffer.getvalue()
+        return result if result else "✅ Code executed successfully."
+    except Exception as e:
+        return str(e)
+
+def delete_job(job_id):
+    if job_id in job_store:
+        del job_store[job_id]
+    return dashboard()
+
+def toggle_auto_refresh():
+    global auto_refresh_enabled
+    auto_refresh_enabled = not auto_refresh_enabled
+    return "✅ Auto-refresh ON" if auto_refresh_enabled else "❌ Auto-refresh OFF"
+
+def explain_code(code):
+    """Send the current code to the AI to generate a fresh explanation."""
+    code = clean_code(code)
+    if not code.strip():
+        return "⚠️ No code to explain."
+    prompt = f"Explain the following Python code in simple terms:\n```python\n{code}\n```"
+    try:
+        explanation = agent.generate_with_ssd(prompt, timeout=120)
+        # Remove code blocks
+        explanation = re.sub(r"```.*?```", "", explanation, flags=re.S).strip()
+        return explanation
+    except Exception as e:
+        return f"⚠️ Error generating explanation: {str(e)}"
+
+# --------------------------------------------------
+# GRADIO UI
+# --------------------------------------------------
+with gr.Blocks(title="PygmyClaw AI Dev Dashboard") as demo:
+    gr.Markdown("# 🧠 PygmyClaw AI Dev Dashboard")
+
+    # ---------------- Create Job ----------------
+    with gr.Row():
+        prompt_input = gr.Textbox(label="Prompt", lines=5, value="write a python function to add two numbers")
+        tool_input = gr.Dropdown(["AI Agent"], value="AI Agent", label="Tool")
+        create_btn = gr.Button("Create Job")
+    create_status = gr.Markdown()
+    job_id_input = gr.Textbox(label="Job ID")  # auto-filled
+    create_btn.click(create_job, inputs=[prompt_input, tool_input], outputs=[create_status, job_id_input])
+
+    # ---------------- Job Dashboard ----------------
+    gr.Markdown("## Job Dashboard")
+    job_table = gr.Dataframe(headers=["Job ID", "Status", "Created", "Prompt", "Code"], interactive=False)
+    refresh_btn = gr.Button("🔄 Refresh Dashboard")
+    refresh_status = gr.Markdown()
+    refresh_btn.click(dashboard, inputs=None, outputs=job_table)
+
+    toggle_btn = gr.Button("⏯ Toggle Auto-Refresh")
+    toggle_btn.click(toggle_auto_refresh, inputs=None, outputs=refresh_status)
+
+    # Auto-refresh dashboard
+    def auto_refresh_dashboard():
+        if auto_refresh_enabled:
+            return dashboard()
+        return gr.update()
+    refresh_timer = gr.Timer(value=5)
+    refresh_timer.tick(auto_refresh_dashboard, inputs=None, outputs=job_table)
+
+    # ---------------- Selected Job ----------------
+    gr.Markdown("## Selected Job Details")
+    load_btn = gr.Button("Load Job")
+    prompt_box = gr.Textbox(label="Prompt", lines=4)
+    response_box = gr.Markdown(label="AI Explanation")
+    code_editor = gr.Code(label="Edit Code", language="python", interactive=True)
+    status_box = gr.Textbox(label="Status")
+    load_btn.click(load_job, inputs=job_id_input, outputs=[prompt_box, response_box, code_editor, status_box])
+
+    # Auto-refresh selected job
+    def auto_refresh_job(job_id):
+        if auto_refresh_enabled:
+            return load_job(job_id)
+        return gr.update(), gr.update(), gr.update(), gr.update()
+    detail_timer = gr.Timer(value=40)
+    detail_timer.tick(auto_refresh_job, inputs=[job_id_input], outputs=[prompt_box, response_box, code_editor, status_box])
+
+    # ---------------- Run / Delete / Explain ----------------
+    with gr.Row():
+        run_btn = gr.Button("▶ Run Code")
+        delete_btn = gr.Button("Delete Job")
+        explain_btn = gr.Button("💡 Explain Code")
+    output_box = gr.Textbox(label="Execution Output", lines=6)
+    explanation_box = gr.Markdown(label="Code Explanation")
+    run_btn.click(run_code, inputs=code_editor, outputs=output_box)
+    delete_btn.click(delete_job, inputs=job_id_input, outputs=job_table)
+    explain_btn.click(explain_code, inputs=code_editor, outputs=explanation_box)
+
+# ---------------- Launch ----------------
+demo.launch(server_name="0.0.0.0", server_port=7860)

desgin.md

@@ -0,0 +1,773 @@
+
+
+# design.md
+
+# PygmyClaw  Agent System
+
+```
+app.py  → UI
+pygmyclaw.py → AI agent + queue + HF storage
+pygmyclaw_multitool.py → tool execution engine
+tools.json → tool registry stored on HuggingFace
+memory.json → task memory stored on HuggingFace
+
+
+
+
+```
+            ┌───────────────┐
+            │   Streamlit   │
+            │    app.py     │
+            └──────┬────────┘
+                   │
+                   ▼
+            ┌───────────────┐
+            │   PygmyClaw   │
+            │  pygmyclaw.py │
+            └──────┬────────┘
+                   │
+          Queue + Agent logic
+                   │
+                   ▼
+        ┌─────────────────────┐
+        │  pygmyclaw_multitool│
+        │     run_tool()      │
+        └─────────────────────┘
+                   │
+                   ▼
+        HF Storage (tools.json / memory.json)
+
+```
+
+```
+## 1. Overview
+
+PygmyClaw is a **local AI agent framework** designed to run in a **Docker Space**.
+
+The system combines:
+
+* speculative decoding for faster generation
+* tool-calling architecture
+* dynamic tool creation
+* artifact generation (files/code/data)
+* background task execution
+* interactive UI
+
+The goal is to create a **self-extensible AI system** where the agent can:
+
+* use tools
+* create new tools
+* generate code
+* install dependencies
+* run programs
+* manage tasks
+* interact through a UI
+
+---
+
+# 2. High-Level System Architecture
+
+```
+User
+ ↓
+HF Space UI (Gradio)
+ ↓
+Agent Engine (pygmyclaw.py)
+ ↓
+Speculative Decoding Engine
+ ↓
+Tool Call Parser
+ ↓
+Tool Executor (subprocess)
+ ↓
+Dynamic Tool Registry
+ ↓
+Workspace / Artifacts / Queue
+ ↓
+Result returned to LLM
+```
+
+---
+
+# 3. System Layers
+
+The system is organized into **five layers**.
+
+## Layer 1 — User Interface
+
+Provides an interactive interface to the agent.
+
+Responsibilities:
+
+* display chat interaction
+* show generated artifacts
+* provide code editor
+* allow running generated code
+* show execution output
+
+UI components:
+
+```
+Chat Panel
+Artifact Viewer
+Code Editor
+Execution Console
+```
+
+Example layout:
+
+```
+----------------------------------
+Chat                | Code Editor
+                    |
+                    | demo_nn.py
+                    |
+                    | [Run] [Save]
+----------------------------------
+Console Output
+----------------------------------
+```
+
+---
+
+# 4. Layer 2 — Agent Engine
+
+Implemented in:
+
+```
+pygmyclaw.py
+```
+
+This is the **central orchestrator** of the system.
+
+Responsibilities:
+
+* manage LLM interaction
+* run speculative decoding
+* parse tool calls
+* execute tools
+* maintain context
+* handle queues
+* coordinate artifacts
+
+The engine runs an **agent execution loop**.
+
+---
+
+# 5. Agent Execution Loop
+
+The entire system is driven by the following loop.
+
+```
+User Prompt
+   ↓
+Agent (LLM)
+   ↓
+LLM outputs JSON tool call
+   ↓
+Tool executes
+   ↓
+Result returned to LLM
+   ↓
+LLM continues reasoning
+   ↓
+Final response
+```
+
+Expanded loop:
+
+```
+User Prompt
+   ↓
+LLM reasoning
+   ↓
+Tool call JSON
+   ↓
+Tool executor
+   ↓
+Tool result
+   ↓
+Context updated
+   ↓
+LLM reasoning continues
+```
+
+The loop stops when the LLM returns **a final answer instead of a tool call**.
+
+---
+
+# 6. Speculative Decoding Engine
+
+PygmyClaw speeds up generation using **speculative decoding**.
+
+Architecture:
+
+```
+Drafter 1
+Drafter 2
+Drafter 3
+   ↓
+Verifier
+```
+
+Flow:
+
+```
+User prompt
+  ↓
+Draft tokens generated
+  ↓
+Verifier checks tokens
+  ↓
+Accept or reject
+```
+
+This improves generation speed while maintaining accuracy.
+
+Typical configuration:
+
+```
+3 draft models
+1 verifier model
+```
+
+Each runs in a separate Ollama instance.
+
+---
+
+# 7. Tool System
+
+Tools allow the agent to perform actions outside the LLM.
+
+Tools run in an isolated subprocess:
+
+```
+pygmyclaw_multitool.py
+```
+
+Execution flow:
+
+```
+Agent
+ ↓
+Tool call JSON
+ ↓
+Subprocess execution
+ ↓
+Tool result JSON
+```
+
+Example tool call:
+
+```
+{
+ "tool": "sys_info",
+ "parameters": {}
+}
+```
+
+Tool response:
+
+```
+{
+ "os": "Linux",
+ "python_version": "3.11"
+}
+```
+
+---
+
+# 8. Tool Categories
+
+The system supports multiple tool types.
+
+## System Tools
+
+```
+sys_info
+list_files
+read_file
+write_file
+```
+
+## Environment Tools
+
+```
+install_python_package
+check_package_installed
+execute_shell
+```
+
+## Code Tools
+
+```
+write_python_code
+run_python_file
+format_code
+```
+
+## Artifact Tools
+
+```
+create_artifact
+update_artifact
+delete_artifact
+```
+
+## Agent Tools
+
+```
+create_agent
+list_agents
+run_agent
+```
+
+---
+
+# 9. Dynamic Tool Creation
+
+Agents can create new tools dynamically.
+
+Example prompt:
+
+```
+create a tool to fetch python documentation
+```
+
+Agent calls:
+
+```
+{
+ "tool": "create_tool",
+ "parameters": {
+  "name": "python_docs",
+  "description": "search python docs"
+ }
+}
+```
+
+System creates:
+
+```
+tools/python_docs.py
+```
+
+Tool becomes immediately available.
+
+This enables **self-extending agents**.
+
+---
+
+# 10. Tool Discovery
+
+At startup the engine scans the tools directory.
+
+```
+tools/
+   echo.py
+   sys_info.py
+   run_python.py
+```
+
+A tool registry is generated.
+
+Example:
+
+```
+TOOLS = {
+ echo,
+ sys_info,
+ run_python
+}
+```
+
+The tool list is provided to the LLM.
+
+---
+
+# 11. Artifact System
+
+Artifacts are files generated by the agent.
+
+Examples:
+
+```
+code
+datasets
+documents
+images
+logs
+```
+
+Directory structure:
+
+```
+artifacts/
+   code/
+   data/
+   documents/
+```
+
+Example artifact:
+
+```
+artifacts/code/addition.py
+```
+
+Artifacts enable **UI interaction**.
+
+---
+
+# 12. Artifact UI Interaction
+
+When artifacts are created the UI displays controls.
+
+Example:
+
+```
+addition.py
+
+Edit
+Run
+Download
+```
+
+Artifact metadata may include:
+
+```
+language
+dependencies
+runnable
+created_by
+```
+
+---
+
+# 13. Workspace Environment
+
+All agent work occurs in a dedicated workspace.
+
+```
+workspace/
+   venv/
+   artifacts/
+   tools/
+   agents/
+```
+
+The workspace provides:
+
+* dependency isolation
+* file management
+* persistent agent data
+
+---
+
+# 14. Dependency Management
+
+Agents may install packages.
+
+Example prompt:
+
+```
+create a pytorch neural network demo
+```
+
+Agent detects dependency:
+
+```
+torch
+```
+
+Tool call:
+
+```
+install_python_package("torch")
+```
+
+Installed inside the workspace environment.
+
+```
+workspace/venv/
+```
+
+---
+
+# 15. Code Generation Workflow
+
+Example request:
+
+```
+create a neural network code demo in python using pytorch
+```
+
+Execution flow:
+
+```
+User prompt
+ ↓
+Agent reasoning
+ ↓
+Install dependency
+ ↓
+Generate code
+ ↓
+Save artifact
+ ↓
+UI displays code
+```
+
+Artifact example:
+
+```
+artifacts/code/pytorch_nn_demo.py
+```
+
+UI shows:
+
+```
+Edit
+Run
+Download
+```
+
+---
+
+# 16. Code Execution Workflow
+
+When the user presses **Run**:
+
+```
+UI
+ ↓
+run_python_file tool
+ ↓
+workspace python interpreter
+ ↓
+program execution
+ ↓
+stdout returned
+```
+
+Console output appears in the UI.
+
+---
+
+# 17. Task Queue
+
+The system supports background tasks.
+
+Queue storage options:
+
+```
+Redis
+JSON file
+```
+
+Example task:
+
+```
+{
+ "id": "123",
+ "prompt": "generate dataset"
+}
+```
+
+Queue worker processes tasks asynchronously.
+
+---
+
+# 18. Agent Registry
+
+Agents are stored as configuration files.
+
+```
+agents/
+   python_coder.json
+   research_agent.json
+```
+
+Example agent definition:
+
+```
+{
+ "name": "python_coder",
+ "model": "qwen2.5",
+ "tools": [
+   "write_python_code",
+   "run_python_file"
+ ]
+}
+```
+
+Agents can be created dynamically.
+
+---
+
+# 19. Redis Usage
+
+Redis is optional but improves scalability.
+
+Uses:
+
+```
+task queue
+agent memory
+caching
+```
+
+Configuration can be stored in Redis or local config.
+
+---
+
+# 20. Hugging Face Space Deployment
+
+The system runs inside a Docker Space.
+
+Components:
+
+```
+Python
+Ollama
+Gradio
+Redis (optional)
+```
+
+Startup sequence:
+
+```
+Start container
+ ↓
+Start Ollama
+ ↓
+Load models
+ ↓
+Start agent engine
+ ↓
+Launch UI
+```
+
+---
+
+# 21. Security Considerations
+
+Important restrictions include:
+
+* package allowlist
+* sandboxed tool execution
+* workspace file isolation
+* limited shell access
+
+Example allowed packages:
+
+```
+numpy
+pandas
+torch
+scikit-learn
+matplotlib
+```
+
+---
+
+# 22. End-to-End Example
+
+User request:
+
+```
+create a neural network code demo in python that uses pytorch
+```
+
+System execution:
+
+```
+User prompt
+ ↓
+Agent reasoning
+ ↓
+install_python_package(torch)
+ ↓
+write_file(pytorch_nn_demo.py)
+ ↓
+artifact created
+ ↓
+UI displays code
+```
+
+User interaction:
+
+```
+Edit code
+Run code
+Download file
+```
+
+Execution output appears in the console.
+
+---
+
+# 23. Final System Architecture
+
+```
+User
+ ↓
+HF Space UI
+ ↓
+Agent Engine
+ ↓
+Speculative Decoding
+ ↓
+Tool Parser
+ ↓
+Tool Executor
+ ↓
+Dynamic Tools
+ ↓
+Workspace
+ ↓
+Artifacts / Agents / Queue
+ ↓
+Result returned to LLM
+```
+
+---
+
+# 24. Design Principles
+
+The system follows several core principles.
+
+1. **Everything is a tool**
+
+Actions are performed through tools rather than hardcoded logic.
+
+2. **Agents can extend themselves**
+
+Agents may create tools and agents.
+
+3. **Artifacts are first-class outputs**
+
+Generated files are accessible through the UI.
+
+4. **Isolation and safety**
+
+Tools run in subprocesses.
+
+5. **Local and lightweight**
+
+System runs entirely locally using Ollama.
+
+---
+
+# 25. Future Extensions
+
+Potential future capabilities include:
+
+```
+multi-agent collaboration
+autonomous project generation
+browser automation
+dataset generation
+long-term memory
+```
+
+---

entrypoint.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -e
+
+echo "Starting Ollama..."
+ollama serve &
+
+sleep 8
+
+echo "Pulling model..."
+ollama pull "${MODEL_NAME}" || true
+
+mkdir -p /workspace/data
+
+echo "Launching Gradio UI..."
+cd /workspace
+python3 app_gradio.py

pygmyclaw.py

@@ -0,0 +1,241 @@
+#!/usr/bin/env python3
+"""
+PygmyClaw – Compact AI Agent with async queue, HF + AI tools support.
+Verbose logging added for debugging.
+"""
+
+import os
+import sys
+import json
+import time
+import queue
+import threading
+import urllib.request
+from pathlib import Path
+import subprocess
+import re
+import textwrap
+from huggingface_hub import hf_hub_download, upload_file
+
+# -------------------- Globals --------------------
+SCRIPT_DIR = Path(__file__).parent.resolve()
+DEFAULT_MODEL = os.environ.get("MODEL_NAME", "qwen3.5:0.8b")
+DEFAULT_ENDPOINT = "http://localhost:11434/api/generate"
+HF_TOKEN = os.environ.get("HF_TOKEN")
+HF_REPO = "rahul7star/pyclaw"
+HF_LOCAL_DIR = SCRIPT_DIR / "pyclaw_hf"
+FILES_TO_DOWNLOAD = ["memory.json", "tools.json"]
+TASK_QUEUE = queue.Queue()
+QUEUE_EVENT = threading.Event()
+
+print(f"[LOG] PygmyClaw loaded. Default model: {DEFAULT_MODEL}")
+
+# -------------------- HF File Download --------------------
+def download_hf_files():
+    HF_LOCAL_DIR.mkdir(parents=True, exist_ok=True)
+    for file_name in FILES_TO_DOWNLOAD:
+        local_path = HF_LOCAL_DIR / file_name
+        if not local_path.exists() or local_path.stat().st_size == 0:
+            try:
+                hf_hub_download(repo_id=HF_REPO, filename=file_name,
+                                token=HF_TOKEN, local_dir=str(HF_LOCAL_DIR))
+                print(f"[LOG] Downloaded {file_name}")
+            except Exception as e:
+                print(f"[WARN] Failed to download {file_name}: {e}")
+                local_path.write_text("{}")
+                print(f"[LOG] Created empty {file_name}")
+
+
+def save_hf_memory():
+        mem_file = HF_LOCAL_DIR / "memory.json"
+        print("[DEBUG] Saving memory locally...")
+        try:
+            with open(mem_file, "w") as f:
+                print("[DEBUG] Local memory saved:", mem_file, "Size:", mem_file.stat().st_size)
+                json.dump(self.memory_data, f, indent=2)
+            upload_file(path_or_fileobj=str(mem_file), path_in_repo="memory.json",
+                        repo_id=HF_REPO, token=HF_TOKEN, repo_type="model")
+            print("[LOG] memory.json updated successfully on HF.")
+        except Exception as e:
+            print(f"[WARN] Failed to push memory to HF: {e}")                
+
+# -------------------- PygmyClaw Agent --------------------
+class PygmyClaw:
+    def __init__(self):
+        self.model = DEFAULT_MODEL
+        self.endpoint = DEFAULT_ENDPOINT
+        self.memory_data = {}
+        self.tools_data = {}
+        self.python_tools = ["Python Script"]
+        download_hf_files()
+        self._load_hf_memory()
+        self._load_hf_tools()
+        self.python_tools += list(self.tools_data.keys())
+        self.python_tools.append("AI Agent")
+        self._ensure_model_ready()
+        self._warmup_model()
+        QUEUE_EVENT.set()
+        threading.Thread(target=self._process_queue, daemon=True).start()
+        self._ssd_backend = "http"
+        print("[LOG] PygmyClaw initialization complete.")
+
+    # -------------------- Memory / Tools --------------------
+    def _load_hf_memory(self):
+        mem_file = HF_LOCAL_DIR / "memory.json"
+        mem_file.parent.mkdir(parents=True, exist_ok=True)
+        if not mem_file.exists() or mem_file.stat().st_size == 0:
+            mem_file.write_text("{}")
+        try:
+            with open(mem_file) as f:
+                self.memory_data = json.load(f)
+            print("[LOG] Loaded memory.json successfully.")
+        except json.JSONDecodeError:
+            self.memory_data = {}
+            print("[WARN] memory.json invalid, initialized empty")
+
+
+   
+    def _save_hf_memory(self, memory_data=None):
+        mem_file = HF_LOCAL_DIR / "memory.json"
+        print("[DEBUG] Saving memory locally...")
+        try:
+            with open(mem_file, "w") as f:
+                print("[DEBUG] Local memory saved:", mem_file, "Size:", mem_file.stat().st_size)
+                json.dump(self.memory_data, f, indent=2)
+            upload_file(path_or_fileobj=str(mem_file), path_in_repo="memory.json",
+                        repo_id=HF_REPO, token=HF_TOKEN, repo_type="model")
+            print("[LOG] memory.json updated successfully on HF.")
+        except Exception as e:
+            print(f"[WARN] Failed to push memory to HF: {e}")
+
+    def _load_hf_tools(self):
+        tools_file = HF_LOCAL_DIR / "tools.json"
+        tools_file.parent.mkdir(parents=True, exist_ok=True)
+        if not tools_file.exists() or tools_file.stat().st_size == 0:
+            tools_file.write_text("{}")
+        try:
+            with open(tools_file) as f:
+                self.tools_data = json.load(f)
+            print("[LOG] Loaded tools.json successfully.")
+        except json.JSONDecodeError:
+            self.tools_data = {}
+            print("[WARN] tools.json invalid, initialized empty")
+
+    # -------------------- Model Ready --------------------
+    def _ensure_model_ready(self):
+        print(f"[LOG] Ensuring model '{self.model}' is ready...")
+        payload = {"model": self.model, "prompt": "hello", "stream": False, "options": {"num_predict": 1}}
+        try:
+            req = urllib.request.Request(self.endpoint, data=json.dumps(payload).encode("utf-8"),
+                                         headers={"Content-Type": "application/json"}, method="POST")
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                resp_data = json.loads(resp.read())
+                if "response" in resp_data:
+                    print("[LOG] Model is ready.")
+        except Exception as e:
+            print(f"[WARN] HTTP model check failed: {e}. Will use CLI fallback if needed.")
+
+    def _warmup_model(self):
+        try:
+            payload = {"model": self.model, "prompt": ".", "stream": False, "options": {"num_predict": 1}}
+            req = urllib.request.Request(self.endpoint, data=json.dumps(payload).encode("utf-8"),
+                                         headers={"Content-Type": "application/json"}, method="POST")
+            with urllib.request.urlopen(req, timeout=5):
+                print("[LOG] Model warmed up.")
+        except Exception:
+            print("[LOG] Warmup skipped, may use CLI fallback.")
+
+    # -------------------- Task Queue --------------------
+    def add_task(self, prompt, tool="AI Agent", callback=None):
+        task_id = str(time.time())
+        TASK_QUEUE.put({"id": task_id, "prompt": prompt, "tool": tool, "callback": callback})
+        print(f"[LOG] Queued task {task_id} with tool={tool}")
+        return task_id
+
+    def _process_queue(self):
+        print("[LOG] Queue processor started...")
+        while QUEUE_EVENT.is_set():
+            try:
+                task = TASK_QUEUE.get(timeout=1)
+            except queue.Empty:
+                continue
+            task_id = task["id"]
+            prompt = task["prompt"]
+            tool = task.get("tool", "AI Agent")
+            callback = task.get("callback", None)
+            print(f"[LOG] Processing task {task_id} -> {prompt}")
+            try:
+                if tool == "Python Script":
+                    local_vars = {}
+                    exec(prompt, {}, local_vars)
+                    result = str(local_vars)
+                else:
+                    result = self.generate_with_ssd(prompt)
+                    print(f"[LOG] Model output for task {task_id}:\n{result}")
+
+                # Save memory only after successful response
+                self.memory_data[task_id] = {
+                    "prompt": prompt,
+                    "response": result,
+                    "timestamp": time.time(),
+                    "tool": tool
+                }
+                self._save_hf_memory(self.memory_data)
+                save_hf_memory()
+                if callback:
+                    callback(result)
+                print(f"[LOG] Task {task_id} completed successfully.")
+
+            except Exception as e:
+                print(f"[ERROR] Task {task_id} failed: {e}")
+            finally:
+                TASK_QUEUE.task_done()
+
+    # -------------------- Unified SSD call with failover --------------------
+    def generate_with_ssd(self, prompt, num_predict=600, timeout=120):
+        output = ""
+        backends_to_try = ["http", "cli"] if self._ssd_backend == "http" else ["cli", "http"]
+        for backend in backends_to_try:
+            if backend == "http":
+                try:
+                    payload = {"model": self.model, "prompt": prompt, "stream": False,
+                               "enable_thinking": False, "options": {"num_predict": num_predict, "temperature": 0.2}}
+                    req = urllib.request.Request(self.endpoint, data=json.dumps(payload).encode("utf-8"),
+                                                 headers={"Content-Type": "application/json"}, method="POST")
+                    with urllib.request.urlopen(req, timeout=timeout) as resp:
+                        output = resp.read().decode("utf-8")
+                    self._ssd_backend = "http"
+                    print("[LOG] HTTP backend succeeded.")
+                    break
+                except Exception as e:
+                    print(f"[WARN] HTTP backend failed: {e}")
+                    output = f"❌ HTTP failed: {e}"
+                    continue
+            elif backend == "cli":
+                try:
+                    result = subprocess.run(["ollama", "run", self.model, prompt],
+                                            capture_output=True, text=True, timeout=600)
+                    output = result.stdout.strip() if result.stdout else result.stderr.strip()
+                    self._ssd_backend = "cli"
+                    print("[LOG] CLI backend succeeded.")
+                    break
+                except subprocess.TimeoutExpired:
+                    output = "⏱️ CLI timed out."
+                    print("[WARN] CLI backend timed out.")
+                except Exception as e:
+                    output = f"❌ CLI failed: {e}"
+                    print(f"[WARN] CLI backend failed: {e}")
+                    continue
+
+        self.memory_data["last_raw_response"] = output
+        try:
+            data = json.loads(output)
+        except json.JSONDecodeError:
+            data = {"response": output}
+
+        full_text = data.get("response", output)
+        code_blocks = re.findall(r"```(?:python)?\s*(.*?)```", full_text, re.S | re.I)
+        code = "\n\n".join(code_blocks)
+        code = textwrap.dedent(code).replace("\t", "    ").strip()
+        self.memory_data["last_code"] = code
+        return full_text

pygmyclaw_multitool.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""
+PygmyClaw Multitool – Contains the actual tool implementations.
+Works both as:
+1) CLI tool (stdin → stdout JSON)
+2) Python module (import + run_tool())
+"""
+
+import json
+import sys
+import os
+import platform
+import time
+from pathlib import Path
+
+SCRIPT_DIR = Path(__file__).parent.resolve()
+
+ERROR_LOG = SCRIPT_DIR / "error_log.json"
+
+MAX_LOG_ENTRIES = 1000
+
+
+# ----------------------------------------------------------------------
+# Tool definitions
+
+TOOLS = {
+    "list_tools_detailed": {
+        "name": "list_tools_detailed",
+        "description": "List all available tools with their descriptions and parameters.",
+        "parameters": {},
+        "func": "do_list_tools"
+    },
+
+    "sys_info": {
+        "name": "sys_info",
+        "description": "Get system information (OS, Python version, etc.).",
+        "parameters": {},
+        "func": "do_sys_info"
+    },
+
+    "log_error": {
+        "name": "log_error",
+        "description": "Log an error message to the error log.",
+        "parameters": {
+            "msg": "string",
+            "trace": "string (optional)"
+        },
+        "func": "do_log_error"
+    },
+
+    "echo": {
+        "name": "echo",
+        "description": "Echo the input text (for testing).",
+        "parameters": {"text": "string"},
+        "func": "do_echo"
+    }
+}
+
+
+# ----------------------------------------------------------------------
+# Tool Implementations
+
+
+def do_list_tools():
+    """Return the list of tools with metadata."""
+
+    tools_list = []
+
+    for name, info in TOOLS.items():
+
+        tools_list.append({
+            "name": name,
+            "description": info["description"],
+            "parameters": info["parameters"]
+        })
+
+    return {"tools": tools_list}
+
+
+def do_sys_info():
+    """Return system information."""
+
+    return {
+        "os": platform.system(),
+        "os_release": platform.release(),
+        "python_version": platform.python_version(),
+        "hostname": platform.node()
+    }
+
+
+def do_log_error(msg, trace=""):
+    """Append an error to the error log."""
+
+    entry = {
+        "timestamp": time.time(),
+        "msg": msg,
+        "trace": trace
+    }
+
+    try:
+
+        if ERROR_LOG.exists():
+
+            with open(ERROR_LOG) as f:
+                log = json.load(f)
+
+        else:
+
+            log = []
+
+        log.append(entry)
+
+        if len(log) > MAX_LOG_ENTRIES:
+            log = log[-MAX_LOG_ENTRIES:]
+
+        with open(ERROR_LOG, "w") as f:
+            json.dump(log, f, indent=2)
+
+        return {"status": "logged"}
+
+    except Exception as e:
+
+        return {"error": f"Failed to write log: {e}"}
+
+
+def do_echo(text):
+    """Echo input."""
+
+    return {"echo": text}
+
+
+# ----------------------------------------------------------------------
+# INTERNAL TOOL EXECUTOR (used by PygmyClaw agent)
+
+def run_tool(action, **params):
+    """
+    Run tool programmatically.
+
+    Example:
+        run_tool("sys_info")
+        run_tool("echo", text="hello")
+    """
+
+    tool = TOOLS.get(action)
+
+    if not tool:
+        return {"error": f"Unknown tool '{action}'"}
+
+    func_name = tool["func"]
+
+    try:
+
+        if func_name == "do_list_tools":
+            return do_list_tools()
+
+        elif func_name == "do_sys_info":
+            return do_sys_info()
+
+        elif func_name == "do_log_error":
+            return do_log_error(
+                params.get("msg"),
+                params.get("trace", "")
+            )
+
+        elif func_name == "do_echo":
+            return do_echo(params.get("text"))
+
+        else:
+            return {"error": f"Unknown function '{func_name}'"}
+
+    except Exception as e:
+
+        return {"error": f"Tool execution failed: {e}"}
+
+
+# ----------------------------------------------------------------------
+# CLI Dispatcher (existing behavior preserved)
+
+def main():
+
+    try:
+
+        raw = sys.stdin.read()
+
+        if not raw:
+            print(json.dumps({"error": "No input"}))
+            return
+
+        data = json.loads(raw)
+
+        action = data.get("action")
+
+        if not action:
+
+            print(json.dumps({"error": "No action specified"}))
+            return
+
+        params = {k: v for k, v in data.items() if k != "action"}
+
+        result = run_tool(action, **params)
+
+        print(json.dumps(result))
+
+    except Exception as e:
+
+        print(json.dumps({"error": f"Multitool exception: {e}"}))
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,8 @@
+streamlit>=1.28.0
+requests>=2.28.0
+ 
+requests>=2.31.0            
+redis>=5.0.0                
+ollama-python>=0.1.0        
+gradio==4.44.0 
+huggingface_hub==0.23.5 

ui.py

@@ -0,0 +1,38 @@
+import streamlit as st
+import subprocess
+from pathlib import Path
+import json
+
+st.set_page_config(page_title="PygmyClaw", layout="wide")
+st.title("🦾 PygmyClaw Autonomous Agent")
+
+# Workspace
+workspace = Path("/workspace/data")
+workspace.mkdir(exist_ok=True)
+
+# User input
+prompt = st.text_area("Enter your prompt:", height=100)
+
+if st.button("Submit Prompt"):
+    st.info("Processing...")
+    # Call pygmyclaw agent
+    result = subprocess.run(
+        ["python3", "pygmyclaw.py", "generate", prompt],
+        capture_output=True, text=True
+    )
+    st.success("Done!")
+    st.code(result.stdout, language="text")
+
+# Optional: code editor + run
+code_files = list(workspace.glob("*.py"))
+if code_files:
+    st.subheader("Generated Python Scripts")
+    for f in code_files:
+        code = f.read_text()
+        edited_code = st.text_area(f.name, code, height=200)
+        if st.button(f"Run {f.name}"):
+            exec_result = subprocess.run(
+                ["python3", "-c", edited_code],
+                capture_output=True, text=True
+            )
+            st.code(exec_result.stdout + "\n" + exec_result.stderr)